Example #1
0
		void CKinematicFlee::move(DynamicMovement& currentProperties)
		{
			CTransform* transf = static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP));
			currentProperties.linearSpeed = transf->getPosition() - m_target;
			currentProperties.linearAccel = currentProperties.linearAccel + currentProperties.linearAccel.crossProduct(Vector3(0.0f, 1.0f, 0.0f));
			currentProperties.linearSpeed.normalise();
			currentProperties.linearSpeed *= m_maxLinearSpeed;
		}
Example #2
0
		void CKinematicSeek::move(DynamicMovement& currentProperties)
		{
			CTransform* transf = static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP));
			currentProperties.linearSpeed = m_target - transf->getPosition();
			if (currentProperties.linearSpeed.length() > m_maxLinearSpeed) {
				currentProperties.linearSpeed.normalise();
				currentProperties.linearSpeed *= m_maxLinearSpeed;
			}
		}
Example #3
0
		void CKinematicArrive::move(DynamicMovement &currentProperties)
		{
			CTransform* transf = static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP));
			currentProperties.linearSpeed = (m_target - transf->getPosition());
			currentProperties.linearSpeed /= IMovement::ATTENUATION;
			if (currentProperties.linearSpeed.squaredLength() > m_maxLinearSpeed2) {
				currentProperties.linearSpeed.normalise();
				currentProperties.linearSpeed *= m_maxLinearSpeed;
			}
		}
Example #4
0
		void CKinematicAlignToTarget::move(DynamicMovement& currentProperties)
		{
			CTransform* transf = static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP));
			Vector3 vec(m_target - transf->getPosition());
			currentProperties.angularSpeed = (atan2(-vec.x, -vec.z) - transf->getYaw());//
			currentProperties.angularSpeed = AI::CAI::correctAngle(currentProperties.angularSpeed);
			//currentProperties.angularSpeed /= IMovement::ATTENUATION;
			if (abs(currentProperties.angularSpeed) > m_maxAngularSpeed) {
				currentProperties.angularSpeed = Ogre::Math::Sign(currentProperties.angularSpeed) * m_maxAngularSpeed;
			}
		}
Example #5
0
		void CSteeringMovement::tick(unsigned int msecs)
		{
			IComponent::tick(msecs);

			using namespace Common::Data;

			//setting the target
			if (m_playerTarget) {
				CEntity* player_target = CLogic::getInstance()->getScene()->getEntityByName("Player");
				if(!player_target) return;

				m_target = static_cast<CTransform*>(player_target->getComponentByName(TRANSFORM_COMP))->getPosition();
				m_yaw->setTarget(m_target);
			}

			//getting info from the movable entity
			CTransform* transf = static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP)); 
			CMovement* movement = static_cast<CMovement*>(m_entity->getComponentByName(MOVEMENT_COMP));

			// Comprobamos si hay que cambiar de movimiento o destino
			if (m_movType != m_currentMovementType || m_currentTarget != m_target) {
				if (m_currentMovement != NULL) {
					delete m_currentMovement;
				}
				m_currentMovementType = m_movType;
				m_currentTarget = m_target;
				m_currentMovement = AI::Movement::IMovement::getMovement(m_currentMovementType, m_maxLinearSpeed, m_maxAngularSpeed, m_maxLinearAccel, m_maxAngularAccel);
				// Si hay un nuevo movimiento
				if (m_currentMovement != NULL) {
					// Ajustamos el target
					m_arrived = false;
					m_currentMovement->setEntity(m_entity);
					m_currentMovement->setTarget(m_currentTarget);
				}
			}

			bool justArrived = !m_arrived && transf->getPosition().positionEquals(m_target, m_tolerance);
			if (justArrived)
				m_arrived = true;

			// Si nos estamos desplazando calculamos la próxima posición
			if (!m_arrived && m_currentMovement != NULL) {
				m_currentMovement->move(m_currentProperties);
			
				// Calculamos la evitación
				if (m_evade != NULL && m_evadeDistance > 0)
				{
					AI::Movement::IMovement::DynamicMovement evadeProperties;
					m_evade->move(evadeProperties);
					// Distancia al objeto a evadir
					Vector3 position = transf->getPosition();
					Vector3 distance = m_evade->getTarget() - position;
					float distanceMagnitude = distance.length();
					if (distanceMagnitude <= m_evadeDistance){
						m_currentProperties.linearAccel += (10.0f * evadeProperties.linearAccel * (msecs * 0.001));
						m_evading = true;
					} else if(m_evading &&  distanceMagnitude <= m_stopEvadeDistance){
						m_currentProperties.linearAccel += (10.0f * evadeProperties.linearAccel  * (msecs * 0.001));
					}else if(distanceMagnitude > m_stopEvadeDistance)
						m_evading = false;
				}else{
					m_evading = false;
				}
	
				// Calculamos la rotación
				if(m_fixedTime >= 0.1f){
					m_yaw->move(m_currentProperties);
					m_fixedTime = 0.0f;
				}else{
					m_fixedTime += msecs * 0.001;
				}

				// Mover
				float speedValue = m_currentProperties.linearSpeed.length();
				movement->setSpeed(speedValue);
				movement->move( Vector3(m_currentProperties.linearSpeed.x, 0.0f,m_currentProperties.linearSpeed.z) );

				// Aplicar la rotación
				float angConst( 0.7/(msecs * 0.01));//5.1
				

				movement->rotate((float)m_currentProperties.angularSpeed * angConst);

				// Acelerar
				m_currentProperties.linearSpeed += m_currentProperties.linearAccel;

				// Clipping
				if (speedValue > m_maxLinearSpeed)
					m_currentProperties.linearSpeed *= (m_maxLinearSpeed / speedValue);

				m_currentProperties.angularSpeed += m_currentProperties.angularAccel;
				if (m_currentProperties.angularSpeed > m_maxAngularSpeed) 
					m_currentProperties.angularSpeed = Ogre::Math::Sign((float)m_currentProperties.angularSpeed) * m_maxAngularSpeed;
			}

			float minTime(1.0f);

			minTime +=(Application::CGameManager::getInstance()->getTotalObjectives() - 
				Application::CGameManager::getInstance()->getObjectivesAquired()) * 0.5f;

			if (m_playerTarget) {
				if ( !m_primary ? m_frequency >= minTime + m_freq(m_generator) :  
					(m_weapons->getPrimaryWeaponType() == Common::Data::Weapons_t::LASER_BEAM ? m_frequency >= minTime + m_freq(m_generator) :
					m_frequency >= ((minTime + m_freq(m_generator))/2.0f)) ) {

					if(m_primary){
						if(m_weapons->getPrimaryWeaponType() == Common::Data::Weapons_t::LASER_BEAM){

							if(((m_weapons->getPrimaryWeapon()->getRange() * m_weapons->getPrimaryWeapon()->getRange()) * 1.1) >= 
						static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP))->getPosition().squaredDistance(m_target) ){
								m_shootingBeam = !m_shootingBeam;
								if(m_shootingBeam)
									m_weapons->shootPrimaryWeapon(msecs);
								else
									m_weapons->getPrimaryWeapon()->releaseTrigger();
							}else{
								m_shootingBeam = false;
								m_weapons->getPrimaryWeapon()->releaseTrigger();
							}

						}else{
							if(((m_weapons->getPrimaryWeapon()->getRange() * m_weapons->getPrimaryWeapon()->getRange()) * 1.1) >= 
						static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP))->getPosition().squaredDistance(m_target) )
							m_weapons->shootPrimaryWeapon(msecs);
						}
					}else{
						if(((m_weapons->getSecondaryWeapon()->getRange() * m_weapons->getSecondaryWeapon()->getRange()) * 1.1) >= 
					static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP))->getPosition().squaredDistance(m_target) )
						m_weapons->shootSecondaryWeapon();
					}

					m_frequency = 0.0f;

				}else{
					m_frequency += (msecs/1000.0f);

					if(m_primary && m_weapons->getPrimaryWeaponType() == Common::Data::Weapons_t::LASER_BEAM && m_shootingBeam){
						if(((m_weapons->getPrimaryWeapon()->getRange() * m_weapons->getPrimaryWeapon()->getRange()) * 1.1) >= 
						static_cast<CTransform*>(m_entity->getComponentByName(TRANSFORM_COMP))->getPosition().squaredDistance(m_target) ){
							m_weapons->shootPrimaryWeapon(msecs);
						}else{
							m_weapons->getPrimaryWeapon()->releaseTrigger();
						}
					}
				}
			}
		}
Example #6
0
/// Step forward the simulation
void Box2DSystem::update(const Time& deltaTime)
{
	mSimulation->Step(deltaTime.seconds(), 8, 8);

	// Compute stuff with the world
	ComponentManager* colliderBoxManager = mWorld->getComponentManager<CColliderBox>();
	ComponentManager* transformManager = mWorld->getComponentManager<CTransform>();

	for (std::size_t i = 0; i < colliderBoxManager->getInstanceCount(); ++i)
	{
		CColliderBox* boxCollider = (CColliderBox*)colliderBoxManager->getInstance(i);
		CTransform* transform = (CTransform*)transformManager->getComponentFromEntity(colliderBoxManager->getInstanceEntity(i));
		if (!transform)
		{
			mWorld->createComponent(CTransform(), colliderBoxManager->getInstanceEntity(i));
			transform = (CTransform*)transformManager->getComponentFromEntity(colliderBoxManager->getInstanceEntity(i));
		}

		if (!boxCollider->userData)
		{
			b2BodyDef groundBodyDef2;
			groundBodyDef2.type = boxCollider->_isDynamic ? b2_dynamicBody : b2_staticBody;
			groundBodyDef2.position = b2Vec2(transform->getPosition().x, transform->getPosition().y);
			b2Body* groundBody2 = mSimulation->CreateBody(&groundBodyDef2);

			b2PolygonShape groundShape2;
			groundShape2.SetAsBox(10.f, 10.f);
			groundBody2->CreateFixture(&groundShape2, 1.f);

			groundBody2->SetUserData(boxCollider);
			boxCollider->userData = groundBody2;
		}
		else
		{
			b2Body* boxColliderBody = (b2Body*)boxCollider->userData;
			transform->position.x = boxColliderBody->GetPosition().x;
			transform->position.y = boxColliderBody->GetPosition().y;
			transform->rotation = Quaternion::fromMatrix(mat4::rotatez(boxColliderBody->GetAngle()));
		}
	}

	// Now let's go through the actors to find stuff in them
	for (std::size_t i = 0; i < mWorld->actors.size(); ++i)
	{
		Actor* actor = mWorld->actors[i];
		SCColliderBox* box = dynamic_cast<SCColliderBox*>(actor->getRootComponent());
		if (box)
		{
			if (!box->userData)
			{
				b2BodyDef groundBodyDef2;
				groundBodyDef2.type = box->_isDynamic ? b2_dynamicBody : b2_staticBody;
				groundBodyDef2.position = b2Vec2(actor->getActorLocation().x, actor->getActorLocation().y);
				b2Body* groundBody2 = mSimulation->CreateBody(&groundBodyDef2);

				b2PolygonShape groundShape2;
				groundShape2.SetAsBox(10.f, 10.f);
				groundBody2->CreateFixture(&groundShape2, 1.f);

				groundBody2->SetUserData(box);
				box->userData = groundBody2;

				box->rigidBody = new RigidBodyBox2D(groundBody2);
				
			}

			// Apply manual forces
			b2Body* boxColliderBody = (b2Body*)box->userData;
			

			CTransform transform = box->t;

			
			transform.position.x = boxColliderBody->GetPosition().x;
			transform.position.y = boxColliderBody->GetPosition().y;
			transform.rotation = Quaternion::fromMatrix(mat4::rotatez(boxColliderBody->GetAngle()));

			// Push the new physics transform back to the actor
			actor->setTransform(transform);
		}
	}
}