void 
Agent::updateLocomote(Ogre::Real deltaTime)
{
	//This is the update locomotion from the previous assignment
	// Set idle animation
	if (mDirection == Ogre::Vector3::ZERO)
	{
		if (nextLocation()) 
        {
			Ogre::Vector3 src = mBodyNode->getOrientation() * Ogre::Vector3::UNIT_Z;
				if ((1.0f + src.dotProduct(mDirection)) < 0.0001f) 
				{
					mBodyNode->yaw(Ogre::Degree(180));
				}
				else
				{
					Ogre::Quaternion quat = src.getRotationTo(mDirection);
					mBodyNode->rotate(quat);
				}
			setBaseAnimation(ANIM_RUN_BASE);
			setTopAnimation(ANIM_RUN_TOP);
		}
	}
	else
	{
       Ogre::Real move = mWalkSpeed * deltaTime;
       mDistance -= move;
	   if (mDistance <= 0.0f)
	   {
		   mBodyNode->setPosition(mDestination);
		   mDirection = Ogre::Vector3::ZERO;
		   if (!nextLocation())
		   {                  
			   setBaseAnimation(ANIM_IDLE_BASE);
			   setTopAnimation(ANIM_IDLE_TOP);
		   } 
		   else
		   {
			   Ogre::Vector3 src = mBodyNode->getOrientation() * Ogre::Vector3::UNIT_Z;
			   if ((1.0f + src.dotProduct(mDirection)) < 0.0001f) 
			   {
				   mBodyNode->yaw(Ogre::Degree(180));
			   }
			   else
			   {
				   Ogre::Quaternion quat = src.getRotationTo(mDirection);
				   mBodyNode->rotate(quat);
			   } 
		   }
	   }
	   else { mBodyNode->translate(mDirection * move); }
	}
	
}
Exemple #2
0
void EnemyController::approach(void)
{
	EnemyPlane* enemy = static_cast<EnemyPlane*>(IDManager::getPointer(_enemyName, ACTOR));
	Ogre::Vector3 temp = FCKnowledge::getSingleton().getPlayerPosition() - enemy->getPosition();
	Ogre::Vector3 direction = temp * enemy->getAxis();
	//std::cout<<direction.x<<" "<<direction.y<<" "<<direction.z<<std::endl;
	if(direction.angleBetween(Ogre::Vector3::NEGATIVE_UNIT_Z) >= Ogre::Radian(Ogre::Degree(1)))
	{
		Ogre::Quaternion test = direction.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_Z);
		Ogre::Degree angle = enemy->getRotateLimit();
		
		double yawNum = test.getYaw().valueDegrees()/(angle*WORLD_UPDATE_INTERVAL).valueDegrees();
		yawNum = Ogre::Math::Clamp(yawNum, -1.0, 1.0);
		enemy->yaw(yawNum);

		double pitchNum = test.getPitch().valueDegrees()/(angle*WORLD_UPDATE_INTERVAL).valueDegrees();
		pitchNum = Ogre::Math::Clamp(pitchNum, -1.0, 1.0);
		enemy->pitch(pitchNum);
		
		double rollNum = test.getRoll().valueDegrees()/(angle*WORLD_UPDATE_INTERVAL).valueDegrees();
		rollNum = Ogre::Math::Clamp(rollNum, -1.0, 1.0);
		enemy->roll(rollNum);
		
	}
	else
	{
		enemy->yaw(0);
		enemy->pitch(0);
		enemy->roll(0);
	}
}
void AnimateableCharacter::update(Ogre::Real timeSinceLastFrame)
{
    updatePosition(timeSinceLastFrame);

    if (mClipTo)
        clipToTerrainHeight();

    Ogre::Vector3 velocity = getVelocity(); // Current velocity of agent
    Ogre::Real speed = velocity.length();

    if(speed > 0.15) {
        //mAnimState->setEnabled(true);
        //mAnimState->addTime(mAnimSpeedScale * speed * timeSinceLastFrame);

        if(speed > 0/*0.8*/) {  // Avoid jitter (TODO keep this?)
            // Rotate to look in walking direction
            Ogre::Vector3 src = getLookingDirection();
            src.y = 0;  // Ignore y direction

            velocity.y = 0;
            velocity.normalise();
            mNode->rotate(src.getRotationTo(velocity));
        }
    } else {    // Assume character has stopped
        mAnimState->setEnabled(false);
        mAnimState->setTimePosition(0);
		}
}
//-----------------------------------------------------------------------------
bool IntermediateTutorial1::frameRenderingQueued(const Ogre::FrameEvent &evt)
{
	if (mDirection == Ogre::Vector3::ZERO) 
	{
		if (nextLocation()) 
		{
			// Set walking animation
			mAnimationState = mEntity->getAnimationState("Walk");
			mAnimationState->setLoop(true);
			mAnimationState->setEnabled(true);

			rotateRobotToDirection();
		}
	}
	else
	{
		Ogre::Real move = mWalkSpeed * evt.timeSinceLastFrame;
		mDistance -= move;
		if (mDistance <= 0.0f)
		{
			mNode->setPosition(mDestination);
			mDirection = Ogre::Vector3::ZERO;

			// Set animation based on if the robot has another point to walk to. 
			if (!nextLocation())
			{
				// Set Idle animation                     
				mAnimationState = mEntity->getAnimationState("Idle");
				mAnimationState->setLoop(true);
				mAnimationState->setEnabled(true);
			} 
			else
			{
				// Rotation Code will go here later
				Ogre::Vector3 src = mNode->getOrientation() * Ogre::Vector3::UNIT_X;
				if ((1.0f + src.dotProduct(mDirection)) < 0.0001f) 
				{
					mNode->yaw(Ogre::Degree(180));
				}
				else
				{
					Ogre::Quaternion quat = src.getRotationTo(mDirection);
					mNode->rotate(quat);
				} // else
			}
		}
		else
		{
			mNode->translate(mDirection * move);
		} // else
	} // if


	mAnimationState->addTime(evt.timeSinceLastFrame);

	return BaseApplication::frameRenderingQueued(evt);
}
Exemple #5
0
void PlayerObject::rotatePlayer() {
    Ogre::Vector3 src = objectNode->getOrientation() * Ogre::Vector3::UNIT_X;
    src.y = 0;
    mDirection.y = 0;
    src.normalise();
    Ogre::Real mDistance = mDirection.normalise();
    Ogre::Quaternion quat = src.getRotationTo(mDirection);

    objectNode->rotate(quat);
    objectNode->yaw(Ogre::Degree(-90));
} // rotatePlayer
//-----------------------------------------------------------------------------
void IntermediateTutorial1::rotateRobotToDirection(void)
{
	Ogre::Vector3 src = mNode->getOrientation() * Ogre::Vector3::UNIT_X;      // Orientation from initial direction
	src.y = 0;                                                    // Ignore pitch difference angle
	mDirection.y = 0;
	src.normalise();
	Ogre::Real mDistance = mDirection.normalise( );                     // Both vectors modified so renormalize them
	Ogre::Quaternion quat = src.getRotationTo(mDirection);

	mNode->rotate(quat);
}
void Tank::rotateTank(void){
	Ogre::Vector3 src = mTankBodyNode->getOrientation() * Ogre::Vector3::NEGATIVE_UNIT_X;
				
	if ((1.0 + src.dotProduct(mDirection)) < 0.0001) 
	{
		mTankBodyNode->yaw(Ogre::Degree(180));
	}
	else
	{
		Ogre::Quaternion quat = src.getRotationTo(mDirection);
		mTankBodyNode->rotate(quat);
	}   
}
//-----------------------------------------------------------------------------------------
bool CCameraEditor::_setViewMode(OgitorsPropertyBase* property, const int& value)
{
    if(value)
    {
        if(mAutoTrackTarget->get() != "None")
            _setAutoTrackTarget(mAutoTrackTarget, "None");

        //Set it to CVM_FREE so we can set to new orientation
        mViewMode->init(0);
        Ogre::Vector3 normal = Ogre::Vector3::UNIT_Z;
        switch(value)
        {
        case CVM_GLOBAL_LEFT: setDerivedOrientation(normal.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_X));break;
        case CVM_GLOBAL_RIGHT: setDerivedOrientation(normal.getRotationTo(Ogre::Vector3::UNIT_X));break;
        case CVM_GLOBAL_FRONT: setDerivedOrientation(normal.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_Z));break;
        case CVM_GLOBAL_BACK: setDerivedOrientation(Ogre::Quaternion::IDENTITY);break;
        case CVM_GLOBAL_TOP: setDerivedOrientation(normal.getRotationTo(Ogre::Vector3::UNIT_Y));break;
        case CVM_GLOBAL_BOTTOM: setDerivedOrientation(normal.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_Y));break;

        case CVM_LOCAL_LEFT: mOrientation->set(normal.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_X));break;
        case CVM_LOCAL_RIGHT: mOrientation->set(normal.getRotationTo(Ogre::Vector3::UNIT_X));break;
        case CVM_LOCAL_FRONT: mOrientation->set(normal.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_Z));break;
        case CVM_LOCAL_BACK: mOrientation->set(Ogre::Quaternion::IDENTITY);break;
        case CVM_LOCAL_TOP: mOrientation->set(normal.getRotationTo(Ogre::Vector3::UNIT_Y));break;
        case CVM_LOCAL_BOTTOM: mOrientation->set(normal.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_Y));break;
        }
        //Restore the value
        mViewMode->init(value);
    }
    else
    {
        if(mAutoTrackTarget->get() != "None")
            _setAutoTrackTarget(mAutoTrackTarget, mAutoTrackTarget->get());
    }

    return true;
}
void PlayerCharacter::updateCharDirMoving(Ogre::Vector3* moveDir, unsigned long timeSinceLastFrame, Ogre::Radian &moveDirRotAngle)
{
	 // TODO: Running backwards goes crazy, turn too fast

	// http://www.ogre3d.org/tikiwiki/Intermediate+Tutorial+1&structure=Tutorials
	// http://www.ogre3d.org/tikiwiki/Quaternion+and+Rotation+Primer#Q._How_can_I_make_my_objects_rotate_smoothly_You_mentioned_slerp_etc_

	if(!moveDir->isZeroLength())
	{
		Ogre::Vector3 src = this->node->getOrientation() * Ogre::Vector3::UNIT_Z;

		if ((1.0f + src.dotProduct(*moveDir)) < 0.0001f) 
		{
			this->node->yaw(Ogre::Degree(180));
		}
		else
		{
			Ogre::Quaternion quat = src.getRotationTo(*moveDir);
			this->node->rotate(quat);
		}
	}

	/*if(!moveDir->isZeroLength())
	{
		//Ogre::Vector3 targetDirection = Quaternion(moveDirRotAngle, Vector3::UNIT_Y) * (*moveDir);
		Ogre::Vector3 targetDirection = this->node->getOrientation() * *moveDir;

		Ogre::Radian rotationDifferenceToLastValue = m_lastTargetDirection.angleBetween(targetDirection);

		Radian targetRotation;

		if(rotationDifferenceToLastValue > Ogre::Radian(Ogre::Real(0.001)))
		{
			Quaternion rotationQuat = (Vector3::UNIT_X).getRotationTo(targetDirection, Vector3::UNIT_Y);

			Radian targetRotation = rotationQuat.getYaw();

			//m_moveRotation.setTargetValueWithAdjustedSmoothtime(targetRotation, true);
			m_moveRotation = targetRotation;
		}


		//m_moveRotation.smoothValue(timeSinceLastFrame);
		this->node->setDirection(0,0,-1, Node::TS_WORLD);
		this->node->yaw(m_moveRotation);

		m_lastTargetDirection = targetDirection;
	}*/
}
Exemple #10
0
void 
Robot::updateLocomote(Ogre::Real deltaTime)
{
	
	if (mDirection == Ogre::Vector3::ZERO)
	{
		if (this->nextLocation()) // a check to see if there is another destination
		{
			// Set walking animation
			this->setBaseAnimation(ANIM_WALK, true);
			this->setTopAnimation(ANIM_WALK, true);
		}
	}
	else
	{
		Ogre::Real move = mWalkSpeed * deltaTime;
		mDistance -= move;

		if (mDistance <= 0.0f) // over shooting target
		{
			this->mBodyNode->setPosition(mDestination);
			mDirection = Ogre::Vector3::ZERO;
			 if (!this->nextLocation()) // a check to see if there is another destination
			 {
				this->setBaseAnimation(ANIM_IDLE, true);
				this->setTopAnimation(ANIM_IDLE, true);
			 }
			 else
			 {
				 Ogre::Vector3 src = this->mBodyNode->getOrientation() * Ogre::Vector3::UNIT_X;
				 if ((1.0f + src.dotProduct(mDirection)) < 0.0001f)
				 {
					 this->mBodyNode->yaw(Ogre::Degree(180));
				 }
				 else
				 {
					Ogre::Quaternion quat = src.getRotationTo(mDirection);
					this->mBodyNode->rotate(quat);
					this->mBodyNode->yaw(Ogre::Degree(angleOffset));  // To correct for models facing different directions
				}
			 }
		}
		else
		{
			this->mBodyNode->translate(mDirection * move);
		}
	}
	
}
Exemple #11
0
void PlayerObject::mousePressed(const OIS::MouseEvent &evt, OIS::MouseButtonID id) {
    if (dead || attacking) {
        return;
    } // if
	int x = evt.state.X.abs;
	int y = evt.state.Y.abs;
	Ogre::Ray mouseRay = camera->getCameraToViewportRay(x/float(evt.state.width), y/float(evt.state.height));
	Ogre::Vector3 point = World::getInstance().getCurrentZone()->getIntersectingPlane(mouseRay);
    point.y = objectNode->getPosition().y;

    if (id == OIS::MB_Left) {
        walkTo = point;
    } // if
    else if (id == OIS::MB_Right) {
        int ran = rand() % 3;
        attacking = true;
        walkTo = objectNode->getPosition();
 
        // Rotate player
        Ogre::Vector3 dir = point - walkTo;
        Ogre::Vector3 src = objectNode->getOrientation() * Ogre::Vector3::UNIT_X;
        src.y = 0;
        dir.y = 0;
        src.normalise();
        Ogre::Real mDistance = dir.normalise();
        Ogre::Quaternion quat = src.getRotationTo(dir);

        objectNode->rotate(quat);
        objectNode->yaw(Ogre::Degree(-90));
        
        switch (ran) {
            case 0:
                mAnimationState = objectEntity->getAnimationState("Attack1");
                break;

            case 1:
                mAnimationState = objectEntity->getAnimationState("Attack2");
                break;

            default:
                mAnimationState = objectEntity->getAnimationState("Attack3");
        } // switch-case
        
        mAnimationState->setTimePosition(0);
        mAnimationState->setLoop(false);
        mAnimationState->setEnabled(true);
        SoundManager::getInstance().ATTACK_MISS_1_SOUND->play();
    } // else if
} // mousePresesd
Exemple #12
0
void Utility::rotateToTarget(Ogre::SceneNode* node,
											  const Ogre::Vector3& target,
											  bool ignoreY,
											  Ogre::Vector3 originalDirection)
{
	Ogre::Vector3 source = node->getOrientation() * originalDirection;
	if(ignoreY)
	{
		source.y = 0;
	}

	node->rotate(source.getRotationTo(target));

	return;
}
Exemple #13
0
	void BaseTower::update(float time)
	{
		if(die)
			return;

		fireCD -= time;

		if(fireCD < 0 && !enemyFactory->enemyList.empty())
		{
			/*
			if(enemyFactory->enemyList.size() == 1)
			{
				Enemy *e= *enemyFactory->enemyList.begin();
				if(e->nearlyDie)
					return;
			}
			*/

			enemy = *enemyFactory->enemyList.begin();


			if(!ifInRange(enemy->getSceneNode()->getPosition(),sceneNode->getPosition(), range))
			{
				return;
			}

			fireCD = 2.0f;
			Ogre::Vector3 src = sceneNode->getOrientation() * Ogre::Vector3::UNIT_X;
			src.y = 0;

			Ogre::Vector3 direction = enemy->getSceneNode()->getPosition() - sceneNode->getPosition();
			direction.y = 0;
			Ogre::Quaternion quat = src.getRotationTo(direction); //direction
			sceneNode->rotate(quat);
			//sceneNode->yaw(Ogre::Degree(90));	

			Bullet *b = bulletFactory->generate(sceneNode->getPosition(), sceneNode->getOrientation(), BULLET_NORMAL);
			Vector3 v = b->getSceneNode()->getPosition();
			v.y = 160;
			b->getSceneNode()->setPosition(v);

			

		}
		
	}
Exemple #14
0
//-------------------------------------------------------------------------------------
bool
PlayersManager::moving(zappy::Player *p, int i)
{
  OPlayer *OPlayer = this->mOPlayers.at(i);
  this->speed = Constants::SquareSize /
    ((Constants::timeUnit / static_cast<Ogre::Real>(time)));

  Ogre::SceneNode *node = OPlayer->getSceneNode();
  Ogre::Vector3 &direction = OPlayer->getDirection();
  Ogre::Real &distance = OPlayer->getDistance();
  Ogre::Real move = this->speed * this->tslf;
  Ogre::Vector3 destination(p->getX() * Constants::SquareSize, 0, p->getY() * Constants::SquareSize);
  Ogre::AnimationState *anim = OPlayer->getEntity()->
    getAnimationState(distance <= 0.0f ? "Idle" : "Walk");

  anim->setLoop(true);
  anim->setEnabled(true);
  if (direction == Ogre::Vector3::ZERO)
    {
      Ogre::Vector3 src = node->getOrientation() * Ogre::Vector3::UNIT_X;
      direction = destination - node->getPosition();
      distance = direction.normalise();
      if ((1.0f + src.dotProduct(direction)) < 0.0001f)
        node->yaw(Ogre::Degree(180));
      else
        node->rotate(src.getRotationTo(direction));
      if (distance > Constants::SquareSize)
        distance = 0.0f;
    }
  else
    {
      distance -= move;
      if (distance <= 0.0f)
        {
          node->setPosition(destination);
          direction = Ogre::Vector3::ZERO;
        }
      else
        node->translate(direction * move);
    }
  if (OPlayer->stateHasChanged())
    OPlayer->detachAnim();
  anim->addTime(this->tslf);
  return true;
}
void Tank::wanderMovement(const float & deltaTime)
{
	if(wanderPathCreated)
	{
		if (mWanderDirection == Ogre::Vector3::ZERO) 
		{
			wanderNextLocation();
		}
		else
		{

			Ogre::Real move = mMoveSpd * (deltaTime);
			mWanderDistance -= move;
			Ogre::Vector3 src = mTankBodyNode->getOrientation() * Ogre::Vector3::NEGATIVE_UNIT_X;
	
			//http://www.ogre3d.org/tikiwiki/tiki-index.php?page=Quaternion+and+Rotation+Primer
			//this is used for rotation of the tank
			if ((1.0 + src.dotProduct(mWanderDirection)) < 0.0001) 
			{
				mTankBodyNode->yaw(Ogre::Degree(180));
			}
			else
			{
				mWanderDirection.y = 0;
				Ogre::Quaternion quat = src.getRotationTo(mWanderDirection);
				
				Ogre::Quaternion mOrientSrc = mTankBodyNode->getOrientation();
				Ogre::Quaternion mOrientDest = quat * mOrientSrc;
				Ogre::Quaternion delta = Ogre::Quaternion::nlerp(deltaTime * 2.0, mOrientSrc, mOrientDest, true);
				mTankBodyNode->setOrientation(delta);
			}      
			//for movement
			if (mWanderDistance <= 0)
			{
				mTankBodyNode->setPosition(mWanderDestination);
				mWanderDirection = Ogre::Vector3::ZERO;
			}
			else
			{
				mTankBodyNode->translate(move * mWanderDirection);
			}
		}
	}
	
}
Exemple #16
0
void Fighter::update(Ogre::Real deltaTime)
{
	Ogre::Vector3 curPos = mNode->getPosition();
	Ogre::Vector3 direction = curPos - mCursorPos;

	Ogre::Vector3 src = mNode->getOrientation() * -Ogre::Vector3::UNIT_Z;
	src.y = 0;                                                   
	direction.y = 0;
	src.normalise();
	direction.normalise();
	
	mNode->setPosition(mNode->getPosition()+mCurrentMoveVector);
	Ogre::Quaternion quat = src.getRotationTo(direction); 

	mNode->rotate(quat);

	/*
	 * Update all shots
	 */
	for(std::vector<Shot*>::iterator it = mShots.begin(); it != mShots.end();)
	{
		(*it)->update(deltaTime);
		/**
		@see	http://www.ogre3d.org/forums/viewtopic.php?t=2519
				http://de.wikipedia.org/wiki/Projektionsmatrix
		 */
		Ogre::Vector3 hcpPos = (*mCameraPtr)->getProjectionMatrix()*(*mCameraPtr)->getViewMatrix()*mNode->getPosition();

		if ((hcpPos.x < -1.0f) || 
		  (hcpPos.x > 1.0f) ||
		  (hcpPos.y < -1.0f) || 
		  (hcpPos.y > 1.0f))
		{
			(*it)->die();
			delete (*it);
			it = mShots.erase(it);
		}
		else
		{
			++it;
		}
	}
	//Update positon for enemies
	mCurrentPosition = mNode->getPosition();
}
void NPCCharacter::_behaviorIdle()
{
	stop();
	//still want to point the character in the direction last traveled.
	Ogre::Vector3 vel = getVelocity();
	float speed = vel.length();
	Ogre::Vector3 src = _node->getOrientation() * Ogre::Vector3::NEGATIVE_UNIT_Z;
	src.y = 0;

	vel.y = 0;
	vel.normalise();
	_node->rotate(src.getRotationTo(vel));

	_isBhvFinished = true;

	//transition to idle animation
	_animHandler.blend("Idle",AnimationBlender::BlendWhileAnimating,.2f,true);
}
void BaseNpc::update(double timeSinceLastFrame)
{
  mAnimationState->addTime(timeSinceLastFrame);

  if (m_pCurrentState) {
    m_pCurrentState->Execute(this);
  }

  if (isMoving == false) {
    if (nextLocation(m_pNpcNode)) {
      // Set walking animation
      mAnimationState = m_pNPC->getAnimationState("Walk");
      mAnimationState->setLoop(true);
      mAnimationState->setEnabled(true);
      isMoving = true;
    } else {
      // Not moving and no locations in list
    }
  } else {
    Ogre::Real move = mWalkSpeed * timeSinceLastFrame;
    mDistance -= move;
    if (mDistance <= 0.0f) {
      m_pNpcNode->setPosition(mDestination);
      mDirection = Ogre::Vector3::ZERO;
      // Set animation based on if the robot has another point to walk to.
      if (! nextLocation(m_pNpcNode)) {
          // Set Idle animation
          mAnimationState = m_pNPC->getAnimationState("Idle");
          mAnimationState->setLoop(true);
          mAnimationState->setEnabled(true);
      } else {
        Ogre::Vector3 src = m_pNpcNode->getOrientation() * Ogre::Vector3::UNIT_X;
        if ((1.0f + src.dotProduct(mDirection)) < 0.0001f) {
          m_pNpcNode->yaw(Ogre::Degree(180));
        } else {
          Ogre::Quaternion quat = src.getRotationTo(mDirection);
          m_pNpcNode->rotate(quat);
        }
      }
    } else {
      m_pNpcNode->translate(mDirection * move);
    }
  }
}
void CharacterMovement::rotate()
{
	if( !_rotating )
	{
		return;
	}

	// linear interpolate
	_rotationValue += _rotationInc;
	if( _rotationValue > 1.0 )
	{
		_rotating = false;
	}
	else
	{
		// Update player's orientation
		Ogre::Vector3 facingVector = _node->getOrientation() * Ogre::Vector3::UNIT_Z;
		Ogre::Vector3 direction = UtilFunctions::qVector3dToOgreVector3( _direction );

		// Work around 180 degree quaternion rotation quirk
		// avoid divide by zero
		// this works our only in case we are walking on non-regular terrain..
		// its irrelevant on plane ground
		if( (1.0f + facingVector.dotProduct( direction )) < 0.0001f )
		{
			_node->yaw( Ogre::Degree(180) );
		}
		else
		{
			Ogre::Quaternion delta;
			Ogre::Quaternion orientationSrc = _node->getOrientation();
			Ogre::Quaternion orientationDest = facingVector.getRotationTo( direction ) * orientationSrc;
			// Slerp
			delta = Ogre::Quaternion::Slerp( _rotationInc, orientationSrc, orientationDest );

			_node->setOrientation( delta );
		}
	}
}
Exemple #20
0
// Returns volume for the right ear.
// If the sound is directly to the right, that channel gets 254 of intensity.
// If the sound is directly in front of us, each channel gets 254/2 of intensity.
int SoundManager::calcPanning(Ogre::Camera* mCamera, Ogre::Vector3 soundPosition) {
    Ogre::Vector3 camDirection = mCamera->getOrientation() * Ogre::Vector3::NEGATIVE_UNIT_Z;
    Ogre::Vector3 soundDir = soundPosition - mCamera->getPosition();
    soundDir.normalise();
    // Retrieve the angle made between the sound position and the camera's direction,
    // which should be pointing forwards.
    Ogre::Quaternion q = camDirection.getRotationTo(soundDir);
    Ogre::Radian radians = q.getYaw();

    // anything left of the camera returns positive degrees
    float degrees = radians.valueDegrees();

    int leftIntensity;
    int rightIntensity;

    // from 0 to -179 it's the right ear.
    if(degrees <= 0) {
      //std::cout << "degrees " << degrees << std::endl;
      degrees *= -1;
      if(degrees > 90)
          degrees = 90 - (degrees - 90); // if 91, we subtract 1 and go back to 89
      // Intensity can never be 255 because then the effect cancels out.
      int intensity = (degrees / 90.0) * 254/2 + 254/2;
      //std::cout << "intensity " << intensity << std::endl;
      rightIntensity = intensity;
      leftIntensity = 255 - (rightIntensity);
    }
    // from 0 to 179 it's the left ear.
    else {
      if(degrees > 90)
          degrees = 90 - (degrees - 90); 
      int intensity = (degrees / 90) * 254/2 + 254/2;
      //std::cout << "intensity " << intensity << std::endl;
      leftIntensity = intensity;
      rightIntensity = 254 - (leftIntensity);
    }
    return rightIntensity;
}
Exemple #21
0
void Monster::go(float timeSinceLastFrame)
{
	
	/// 给动画增加时间
	addTimeToAnimation(timeSinceLastFrame);
	if(!mIsDead)
	{
		if(mDistance < 0.0f || mDistance == 0.0f)
		{
			int size = ogrePath.size();
			mNode->setPosition(ogrePath[mNextPosIndex]);
			if(ogrePath[ogrePath.size()-1] != mNode->getPosition())
			{
				mBeginPosIndex++;
				mNextPosIndex++;
				mDistance = distance(ogrePath[mNextPosIndex], ogrePath[mBeginPosIndex]);
				/// 面向,方向向量
				mFace = (ogrePath[mNextPosIndex] - ogrePath[mBeginPosIndex]);
				mFace.normalise();
			
				/// 旋转面向角度
				Ogre::Vector3 src = mNode->getOrientation() * Vector3::UNIT_X; 
				Ogre::Quaternion quat = src.getRotationTo(mFace);
				mNode->rotate(quat);
			}
			else
			{
				setBlood(0);
				mIsGetUFO = true;
			}
		}
	
		/// 平移所需要走的路
		float moveDistance =  timeSinceLastFrame * mSpeedCurrent;
		mNode->translate(mFace * moveDistance);
		mDistance -= moveDistance;
	}
}
//code taken and adapted from http://natureofcode.com/book/chapter-6-autonomous-agents/
//written by Michael Kong
void Tank::seek(const Ogre::Vector3& target, const float& deltaTime){

	Ogre::Vector3 seekTarget = target;
	seekTarget.y = 0.f;

	Ogre::Quaternion tankOrientation = mTankBodyNode->getOrientation();
	Ogre::Vector3 currentDirection = tankOrientation * Ogre::Vector3::NEGATIVE_UNIT_X; 
	currentDirection.normalise();

	Ogre::Vector3 desired = seekTarget - mTankBodyNode->getPosition();
	desired.normalise(); //get unit vector
	desired *= ms;

	Ogre::Vector3 src = tankOrientation * Ogre::Vector3::NEGATIVE_UNIT_X; 
	Ogre::Quaternion quat = src.getRotationTo(seekTarget);
/*
	Ogre::Quaternion mOrientSrc = mTankBodyNode->getOrientation();
	Ogre::Quaternion mOrientDest = quat * mOrientSrc;
*/
	mTankBodyNode->setOrientation(quat * deltaTime);

	mTankBodyNode->translate(desired * deltaTime);
}
//Probably the most involved behavior so far.
void NPCCharacter::_behaviorTalk(const std::string& targetName)
{
	//have to start moving to the target entity until the distance is acceptable
	LevelData::BaseEntity* targetEnt = LuaManager::getSingleton().getEntity(targetName);

	//Can't talk to a trigger zone or door(though I *could* do the door, it would be an easter egg).
	if(targetEnt->getType() != LevelData::NPC && targetEnt->getType() != LevelData::ENEMY)
	{
		_isBhvFinished = true;
		return;
	}

	if(targetEnt->getType() == LevelData::NPC)
	{
		NPCCharacter* targetNpc = static_cast<NPCCharacter*>(targetEnt);

		//choosing to ignore the y-value to get a true 4 unit distance horizontally from the target.
		//might remove if it doesn't make a difference.
		Ogre::Vector3 tgtNpc = targetNpc->getPosition(); tgtNpc.y = 0;
		Ogre::Vector3 pos = getPosition(); pos.y = 0;

		//position has to be less than 16 units to talk to the entity.
		//chose to use 18 instead due to float inaccuracies(might have a value like 16.0178)
		if(tgtNpc.squaredDistance(pos) > 18)
		{
			//move towards the entity(not using the _behaviorMove function though)
			//or can I??
			//yes I can actually. *does a jig*
			//generate a more correct position
			Ogre::Vector3 target,tmp;
			tmp = targetNpc->getPosition() - getPosition(); //distance and direction to the target
			tmp.y = 0;
			Ogre::Real len = tmp.normalise();
			//original + (unit direction vector * desired distance from target[non-squared])
			target = getPosition() + (tmp * ( len - 1));

			_behaviorMove(target);

			if(_isBhvFinished)
			{
				//reached the destination, but behavior isn't done yet.
				_isBhvFinished = false;
			}
		}
		else
		{
			//rotate to face the target
			Ogre::Vector3 dir = tgtNpc - pos; dir.normalise();
			Ogre::Vector3 src = _node->getOrientation() * Ogre::Vector3::NEGATIVE_UNIT_Z;
			src.y = 0;

			_node->rotate(src.getRotationTo(dir));

			//make sure any other blends are finished first.
			if(_animHandler.getTarget() == nullptr)
			{
				//this ends the behavior until the talk animation or sound file is implemented
				_isBhvFinished = true;

				//this would be the actual way to finish the behavior(or even with the end of a sound file)
				if(_animHandler.getSource()->getAnimationName() == "Talk")
				{
					_isBhvFinished = true;
				}
				else
				{
					//start the blend to the talk animation.
					//_animHandler.blend([animation],[blend technique],.2,true);
				}
			}
		}

		return;
	}

	if(targetEnt->getType() == LevelData::ENEMY)
	{
		//nothing for now.

		return;
	}


	return;
}
Exemple #24
0
	void EnemyDragon::update(float time)
	{
			if(fireLastingTime > 0)
			{
				fireLastingTime -= time;
				ps->setVisible(true);
			}else
				ps->setVisible(false);

			
			if(frostLastingTime <=0)
				frostCoefficient = 1;
			else
				frostLastingTime -= time;

			if(attackToHome)
			{
				attackToHome = false;
				userGUI->resetHealthBar(50);
				//mWorld->homeHealth -= 100;
				//mWorld->homeText->setCaption(convertInt(mWorld->homeHealth));
			}


			if(die){
				mtext->setCaption("0");
				mtext->setVisible(false);
				return;
			}
			if(saveBody < 0){
				die = true;
				mtext->setCaption("0");
				return;
			}
			 
			if(!nearlyDie && !die)
			{
				mtext->setCaption(convertInt(lifeValue));
			}else{
				mtext->setCaption("0");
				mtext->setVisible(false);
			}


			if(nearlyDie)
			{
				mAnimationState= entity->getAnimationState("Death");
				mAnimationState->setLoop(false);
				mAnimationState->setEnabled(true);
				nearlyDieTime -= time;

				if(nearlyDieTime < 0)
				{
					saveBody -= time;
					mAnimationState= entity->getAnimationState("Death");
					//die = true;
					//cleanBody = true;
				}
				mAnimationState->addTime(time * frostCoefficient);
				return;
			}

			if(caught)
				return;



		    if (mDirection == Ogre::Vector3::ZERO) {
				if (nextLocation()) {
					// Set walking animation
					mAnimationState = entity->getAnimationState("Run");
					mAnimationState->setLoop(true);
					mAnimationState->setEnabled(true);				
				}//if
			}else{
				Ogre::Real move = mWalkSpeed * time * frostCoefficient;
				mDistance -= move * frostCoefficient;
				if (mDistance <= 0.0f){                 
					sceneNode->setPosition(mDestination);
					mDirection = Ogre::Vector3::ZERO;				
					// Set animation based on if the robot has another point to walk to. 
					if (!nextLocation()){
						// Set Jump animation                     
						mAnimationState = entity->getAnimationState("BattleRoar");
						mAnimationState->setLoop(true);
						mAnimationState->setEnabled(true);
						nearlyDie = true;  
						attackToHome = true;
						mtext->setCaption("0");
					}else{
						// Rotation Code will go here later
						Ogre::Vector3 src = sceneNode->getOrientation() *(- Ogre::Vector3::UNIT_Z);
						if ((1.0f + src.dotProduct(mDirection)) < 0.0001f) {
							sceneNode->yaw(Ogre::Degree(180));						
						}else{
							Ogre::Quaternion quat = src.getRotationTo(mDirection);
							sceneNode->rotate(quat);
							sceneNode->yaw(Ogre::Degree(90));	
						} // else
					}//else
				}else{
					sceneNode->translate(mDirection * move * frostCoefficient);
				} // else
			} // if
			mAnimationState->addTime(time * frostCoefficient);

			

			if(reachHome)
			{
				ps->setVisible(true);
				happy2Dead -= time;
				if(happy2Dead < 0)
				{
					die = true;
				}
			}
		
	}
Exemple #25
0
void Ninja::updateLocomote(Ogre::Real deltaTime)
{
    int xOffset = ((this->grid->getRows() * this->grid->getHeight()) - this->grid->getHeight())/2;
    int yOffset = ((this->grid->getCols() * this->grid->getHeight()) - this->grid->getHeight())/2;
    int x = (xOffset + mDestination.x)/grid->getHeight();
    int y = (yOffset + mDestination.z)/grid->getHeight();

    if (mDirection == Ogre::Vector3::ZERO)
    {
        if (nextLocation()) // a check to see if there is another destination
        {
            // Set walking animation
            this->setBaseAnimation(ANIM_WALK, true);
            //this->setTopAnimation(ANIM_WALK, true);
        }
    }
    else
    {
        Ogre::Real move = mWalkSpeed * deltaTime;
        mDistance -= move;

        if (mDistance <= 0.0f) // over shooting target
        {
            this->mBodyNode->setPosition(mDestination);

            this->setCurrentNode(grid->getNode(x, y));

            while(this->getCurrentNode()->getItemList()->size() > 0)
            {
                Ogre::Entity* ent = this->getCurrentNode()->getItemList()->front();
                this->inventory->push_back(ent);
                this->getCurrentNode()->getItemList()->pop();
                ent->detachFromParent();

                this->getmBodyEntity()->attachObjectToBone("Joint13", ent);
                ent->getParentNode()->scale(1.15f,1.15f,1.15f);

                ent->setVisible(true);
            }

            mDirection = Ogre::Vector3::ZERO;
            if (!nextLocation()) // a check to see if there is another destination
            {
                this->setCurrentNode(grid->getNode(x, y));
                this->setBaseAnimation(ANIM_IDLE_1, true);
                //this->setTopAnimation(ANIM_IDLE_1, true);
            }
            else
            {

                Ogre::Vector3 src = this->mBodyNode->getOrientation() * Ogre::Vector3::UNIT_X;
                if ((1.0f + src.dotProduct(mDirection)) < 0.0001f)
                {
                    this->mBodyNode->yaw(Ogre::Degree(180));
                }
                else
                {
                    Ogre::Quaternion quat = src.getRotationTo(mDirection);
                    this->mBodyNode->rotate(quat);
                    this->mBodyNode->yaw(Ogre::Degree(angleOffset));  // To correct for models facing different directions
                }
            }
        }
        else
        {
            this->mBodyNode->translate(mDirection * move);
        }
    }
}
void Game::createCallbacks()
{
	App::createCallbacks();

	// Quit on Xbox remote BACK.
	OnFrameRenderingQueued.Subscribe([&](const FrameEventArgs* args) {
		playing = !xboxCtrl.p1.getState().buttons[XboxController::BACK];
	});

#pragma region Helpers
	// Update an animation pair.
	static const auto updateAnimPair = [&](int i, Ogre::Real dt) {
		animStates[i]->addTime(dt);
		animStates[i + 1]->addTime(dt);
	};

	// Toggle enabled for an animation pair.
	static const auto setEnabledAnimPair = [&](int i, bool enabled) {
		animStates[i]->setEnabled(enabled);
		animStates[i + 1]->setEnabled(enabled);
	};
#pragma endregion

	// Toggle animations. 
	OnFrameRenderingQueued.Subscribe([&](const FrameEventArgs* args) {
		if (sinbad->getAcceleration().isZeroLength()) {
			setEnabledAnimPair(0, true);
			setEnabledAnimPair(2, false);
			updateAnimPair(0, args->evt->timeSinceLastFrame);
		}
		else {
			setEnabledAnimPair(0, false);
			setEnabledAnimPair(2, true);
			updateAnimPair(2, args->evt->timeSinceLastFrame);
		}
	});

	// Control Sinbad.
	OnFrameRenderingQueued.Subscribe([&](const FrameEventArgs* args) {
		const auto& leftStick = xboxCtrl.p1.getState().leftStick;
		const auto& rightStick = xboxCtrl.p1.getState().rightStick;

		// Invert the y so stick up goes into screen.
		sinbad->setAcceleration(Ogre::Vector3(leftStick.x, 0, -leftStick.y).normalisedCopy());

		// Keep him facing the move direction.
		Ogre::Vector3 dir = sinbad->getAcceleration().normalisedCopy();
		Ogre::Vector3 src = sinbad->getNode()->getOrientation() * Ogre::Vector3::UNIT_Z;

		// Ignore pitch.
		dir.y = 0;
		dir.normalise();

		src.y = 0;
		src.normalise();

		sinbad->getNode()->rotate(src.getRotationTo(dir));

		sinbad->update(args->evt);

		cameraMan->setYawPitchDist(Ogre::Degree(rightStick.x), Ogre::Degree(rightStick.y), 45.0f);
	});
}
Exemple #27
0
//-----------------------------------------------------------------------------------------
void CLightEditor::_calculateOrientation()
{
    Ogre::Vector3 direction = mHandle->getDerivedDirection();
    Ogre::Vector3 normal = Ogre::Vector3::UNIT_Z;
    mOrientation->initAndSignal( normal.getRotationTo(direction) );
}
//----------------------------------------------------------------------------
int CDotSceneSerializer::ReadLight(TiXmlElement *element, CBaseEditor *parent, CBaseEditor **ret)
{
    OgitorsPropertyValueMap params;
    OgitorsPropertyValue propValue;
 
    propValue.propType = PROP_STRING;
    Ogre::String name = ValidAttr(element->Attribute("name"));
    if(Ogitors::OgitorsRoot::getSingletonPtr()->FindObject(name))
        propValue.val = Ogre::Any(Ogre::String("Light") + Ogitors::OgitorsRoot::getSingletonPtr()->CreateUniqueID("Light",""));
    else
        propValue.val = Ogre::Any(name);

    params["name"] = propValue;
 
    int ltype = Ogre::Light::LT_POINT;
    Ogre::String lighttype = ValidAttr(element->Attribute("type"),"point");
    
    if(lighttype == "directional")
        ltype = Ogre::Light::LT_DIRECTIONAL;
    else if(lighttype == "spot")
        ltype = Ogre::Light::LT_SPOTLIGHT;

    propValue.propType = PROP_INT;
    propValue.val = Ogre::Any(ltype);
    params["lighttype"] = propValue;

    propValue.propType = PROP_BOOL;
    propValue.val = Ogre::Any(Ogre::StringConverter::parseBool(ValidAttr(element->Attribute("castShadows"))));
    params["castshadows"] = propValue;
    propValue.propType = PROP_REAL;
    propValue.val = Ogre::Any(Ogre::StringConverter::parseReal(ValidAttr(element->Attribute("power"), "1")));
    params["power"] = propValue;

    TiXmlElement* subs = 0;
    Ogre::String eType;
    subs = element->FirstChildElement();
    if(!subs) return SCF_OK;
    do
    {
        eType = subs->Value();
        if(eType == "colourDiffuse")
        {
            params["diffuse"] = parseColourValue(subs);
        }
        else if(eType == "colourSpecular")
        {
            params["specular"] = parseColourValue(subs);
        }
        else if(eType == "lightAttenuation")
        {
            Ogre::Vector4 att;
            att.x = Ogre::StringConverter::parseReal(ValidAttr(subs->Attribute("range")));
            att.y = Ogre::StringConverter::parseReal(ValidAttr(subs->Attribute("constant")));
            att.z = Ogre::StringConverter::parseReal(ValidAttr(subs->Attribute("linear")));
            att.w = Ogre::StringConverter::parseReal(ValidAttr(subs->Attribute("quadric")));
            propValue.propType = PROP_VECTOR4;
            propValue.val = Ogre::Any(att);
            params["attenuation"] = propValue;
        }
        else if(eType == "lightRange")
        {
            Ogre::Vector3 range;
            range.x = Ogre::StringConverter::parseReal(ValidAttr(subs->Attribute("inner"),"15"));
            range.y = Ogre::StringConverter::parseReal(ValidAttr(subs->Attribute("outer"),"30"));
            range.z = Ogre::StringConverter::parseReal(ValidAttr(subs->Attribute("falloff"),"1"));
            propValue.propType = PROP_VECTOR3;
            propValue.val = Ogre::Any(range);
            params["lightrange"] = propValue;
        }
        else if(eType == "position")
        {
            params["position"] = parseVector3(subs);
        }
        else if(eType == "directionVector")
        {
            params["direction"] = parseVector3(subs);
            /* Orientation is not stored for lights in the .scene files.
              If we don't set orientation for the spotlights/directional
              lights they will face to the default direction             */
            Ogre::Vector3 normal = Ogre::Vector3::UNIT_Z;
            Ogitors::OgitorsPropertyValue pOrient;

            pOrient.propType = PROP_QUATERNION;
            pOrient.val = normal.getRotationTo(Ogre::any_cast<Ogre::Vector3>(parseVector3(subs).val));
            params["orientation"] = pOrient;
        }
    } while(subs = subs->NextSiblingElement());
    
    *ret = Ogitors::OgitorsRoot::getSingletonPtr()->CreateEditorObject(parent, "Light Object", params, false, false);
    return SCF_OK;
}
Exemple #29
0
void Node::setDirection(Ogre::Vector3 direction, Ogre::Vector3 front_vector) {
    setRotation(front_vector.getRotationTo(direction, Ogre::Vector3::UNIT_X));
}
Exemple #30
0
bool Character::update(const Ogre::FrameEvent& evt)
{

	if(mState == ST_DEAD) // если мертвый, оставляем только текущую анимацию и выходим
	{ 
		mGraphicBody->update(evt); 
		return 0;
	}

	// посчитаем не спал ли статус
	if(mStatus.lockTime >0)
	{
		mStatus.lockTime -= evt.timeSinceLastFrame;
	}
	else //if (mStatus.status != STATUS_NORMAL)
	{
		addStatus(STATUS_NORMAL, "", 0);
		StatusMoveVec = Ogre::Vector3::ZERO; //перемещаеть этим вектором можно только под статусом    
	}

	// повернем лицом к противнику
	Ogre::Vector3 direction = mTargetNode->getPosition() - mNode->getPosition();
	direction.y = 0;
	Ogre::Real distance = direction.normalise();

	if(distance > 0.2)
	{
		Ogre::Vector3 src = mNode->getOrientation() * Ogre::Vector3::UNIT_X;
		src.y = 0;
	    if ((1.0f + src.dotProduct(direction)) < 0.0001f) 
	    {
	        mNode->yaw(Ogre::Degree(180));
	    }
	    else
	    {
	        Ogre::Quaternion quat = src.getRotationTo(direction);
	        mNode->rotate(quat);
	    } // else

	    mPhysicsBody->setOrientation(cvt(mNode->getOrientation()));
	}
	//------------------------------------------------------------------

	if(mState == ST_ATACK && !mPhysicsBody->isLock()) // если атака закончилась
	{
		mState = ST_NOTHING; 
	}

	if(mState != ST_WALK && mState != ST_RUN) MoveVec = Ogre::Vector3::ZERO; // занулим если не передвигаемся
	Ogre::Vector3 newPosition = mNode->getPosition() + (MoveVec + StatusMoveVec + pushVec + JumpVec)*evt.timeSinceLastFrame;
	mNode->setPosition(newPosition);
	pushVec = Ogre::Vector3::ZERO; // занулим, если вдруг возникнет персечение объектов то этот вектор опять пропишеться

	if(mPose == POSE_JUMP)  // считаем прыжек
	{
		if(newPosition.y >= 0) 
		{
			Ogre::Real newY = JumpVec.y - 10 * evt.timeSinceLastFrame;   //учтем гравитацию
			JumpVec = Ogre::Vector3(JumpVec.x, newY, JumpVec.z);    //
		}
		else   //приземление после прыжка
		{
			mPose = POSE_STAND;
			JumpVec = Ogre::Vector3::ZERO;
			mGraphicBody->a_stance(); 
			mGraphicBody->setAnimationRate(1);
			mPhysicsBody->setBaseBodiesTransforms();
			mMoveDir = MV_NULL;
			mPhysicsBody->break_atack(1);
		}
	}

	mPhysicsBody->setPosition(cvt(newPosition));

	if(mGraphicBody->isAnimationComplete()) //на всякий случай - чтобы при отсутствии анимаций стоял в стойке
	{
		mGraphicBody->a_stance(); 
		mGraphicBody->setAnimationRate(1);
	}

	mPhysicsBody->update(evt);
	mGraphicBody->update(evt);

}