Beispiel #1
0
Task* TaskMap<CostInfo>::getTaskForWorker(Creature* c) {
  Task* closest = nullptr;
  for (PTask& task : tasks) {
    if (auto pos = getPosition(task.get())) {
      double dist = (*pos - c->getPosition()).length8();
      const Creature* owner = getOwner(task.get());
      if (!task->isDone() && (!owner || (task->canTransfer() && (*pos - owner->getPosition()).length8() > dist))
          && (!closest || dist < (*getPosition(closest) - c->getPosition()).length8()
              || isPriorityTask(task.get()))
          && (!delayedTasks.count(task->getUniqueId()) || delayedTasks.at(task->getUniqueId()) < c->getTime())) {
        bool valid = task->getMove(c);
        if (valid) {
          closest = task.get();
          if (isPriorityTask(task.get()))
            return task.get();
        }
      }
    }
  }
  return closest;
}
//----[  compile  ]------------------------------------------------------------
void SwarmSpawnMapLayer::compile(
    const RECT* area,
    MapCompilationContext* compilation_context) {
  SwarmSpawnMapLayerCompliationFunctionoid functionoid;
  functionoid.clear_existing = clear_existing_.getValue();
  functionoid.number_to_add = number_to_add_.getValue();

  const dc::dcGenericResource::Array& swarm_spawns
    = swarm_spawns_.getMembers();
  functionoid.number_of_spawn_data = swarm_spawns.size();
  typedef dc::dcList<SwarmSpawn>::Element Element;
  for (int i = 0; i < functionoid.number_of_spawn_data; ++i) {
    Element* element = (Element*)(swarm_spawns.at(i));
    assert(element);
    element->compile(&functionoid.data[i]);
  }
  mask_area_.processMaskLocations(getOwner()->getIndex(),
                                  area,
                                  compilation_context,
                                  &functionoid);
}
Beispiel #3
0
bool BulletCache::isBulletCollidingWithRect(cocos2d::Rect rect, bool usePlayerBullets){
    bool isColliding = false;
    for (auto b : batch->getChildren()) {
        if (dynamic_cast<Bullet *>(b)) {
            auto bullet = dynamic_cast<Bullet *>(b);
            if (bullet->isVisible() && usePlayerBullets == bullet->getIsPlayerBullet()) {
                if (bullet->getBoundingBox().intersectsRect(rect)) {
                    isColliding = true;
                    
                    // remove the bullet
                    bullet->getOwner()->setReload(false);
                    bullet->setVisible(false);
                    bullet->unscheduleUpdate();
                    break;
                }
            }
        }
    }
    
    return isColliding;
}
Beispiel #4
0
void UnitBase::setTarget(const ObjectBase* newTarget) {
	attackPos.invalidate();
	bFollow = false;
	targetAngle = INVALID;

	if(goingToRepairYard && target && (target.getObjPointer()->getItemID() == Structure_RepairYard)) {
		((RepairYard*)target.getObjPointer())->unBook();
		goingToRepairYard = false;
	}

	ObjectBase::setTarget(newTarget);

	if(target.getObjPointer() != NULL
		&& (target.getObjPointer()->getOwner() == getOwner())
		&& (target.getObjPointer()->getItemID() == Structure_RepairYard)
		&& (itemID != Unit_Carryall) && (itemID != Unit_Frigate)
		&& (itemID != Unit_Ornithopter)) {
		((RepairYard*)target.getObjPointer())->book();
		goingToRepairYard = true;
	}
}
void SwgPlayerCreatureController::handleMessage (const int message, const float value, const MessageQueue::Data* const data, const uint32 flags)
{
	SwgCreatureObject * const owner = safe_cast<SwgCreatureObject*>(getOwner());
	SwgPlayerObject * playerOwner = safe_cast<SwgPlayerObject*>(getPlayerObject(owner));
	NOT_NULL(playerOwner);

	switch (message)
	{
	case CM_setJediState:
		{
			const MessageQueueGenericValueType<int> * const msg = dynamic_cast<const MessageQueueGenericValueType<int> *>(data);
			if (msg != NULL)
				playerOwner->setJediState(static_cast<JediState>(msg->getValue()));
		}
		break;

	default:
		PlayerCreatureController::handleMessage(message, value, data, flags);
		break;
	}
}
void ComponentPhysicsSetVelocity::tick (DTfloat dt)
{
    if (dt <= 0.0F)
        return;

    PlaceableObject *placeable = checkedCast<PlaceableObject*>(getOwner());
    if (!placeable)
        return;
        
    Matrix4 current_transform = placeable->getTransform();
            
    // Velocity is easy
    placeable->setVelocity( (current_transform.translation() - _last_transform.translation()) / dt );
    
    // Angular velocity is more difficult
    // See: http://www.physicsforums.com/showthread.php?t=477556
    
    // M' = exp(A * dt) M   where
    //  M' = next orientation
    //  M  = current orientation
    //  A  = skew symmetric matrix
    //          [ 0   -Az Ay  ]
    //          | Az  0   -Ax ]
    //          [ -Ay Ax  0   ]
    // So (1/dt) * log[M'/M] = A
    // To compute the logarithm, let Y = M'/M - I where I is the identity matrix
    // Then log(M'/M) = log(I + Y) = Y - Y^2/2 + Y^3/3 - Y^4/4 + etc.

    Matrix3 Y = current_transform.orientation() * _last_transform.orientation().inversed() - Matrix3::identity();
    Matrix3 Y2 = Y*Y;
    Matrix3 Y3 = Y2*Y;
    Matrix3 Y4 = Y3*Y;
    
    Matrix3 A = (Y - Y2/2.0F + Y3/3.0F - Y4/4.0F) / dt;
    
    placeable->setAngularVelocity(Vector3(A._m32, A._m13, A._m21));
    
    // Copy current transform
    _last_transform = current_transform;
}
Beispiel #7
0
void Planet::doOnceATurn()
{
  if (getOwner() != 0) {
    uint32_t factories = dynamic_cast<IntegerObjectParam*>(obj->getParameter(5,1))->getValue();
    ResourceManager::Ptr resman = Game::getGame()->getResourceManager();
    const uint32_t restype = resman->getResourceDescription("Factories")->getResourceType();

    if (factories < 100)
    {
      Logger::getLogger()->debug("Planet::doOnceATurn Factories(%d) less than 100, incrementing by 1", factories);
      factories++;
      dynamic_cast<IntegerObjectParam*>(obj->getParameter(5,1))->setValue(factories);
      //reset factories resource every turn, assume all points used
      setResource(restype, factories);
    }
    // Add the once-per-turn points
    const uint32_t sentPoints = dynamic_cast<IntegerObjectParam*>(obj->getParameter(5,2))->getValue();
    Logger::getLogger()->debug("Planet::doOnceATurn Adding once-per-turn points: %d", sentPoints);
    addResource(restype, sentPoints);
    dynamic_cast<IntegerObjectParam*>(obj->getParameter(5,2))->setValue(0);
  }
}
Beispiel #8
0
void LayoutMap::setCurrentLayout(int layoutUnit) {
	LayoutQueue& layoutQueue = getCurrentLayoutQueue();
	kDebug() << "map: Storing layout: " << layoutUnit << " for " << getOwner();
	
	int queueSize = (int)layoutQueue.count();
	for(int ii=0; ii<queueSize; ii++) {
		if( layoutQueue.head() == layoutUnit )
			return;	// if present return when it's in head
		
		int layoutState = layoutQueue.dequeue();
		if( ii < queueSize - 1 ) {
			layoutQueue.enqueue(layoutState);
		}
		else {
			layoutQueue.enqueue(layoutUnit);
		}
	}
	for(int ii=0; ii<queueSize - 1; ii++) {
		int layoutState = layoutQueue.dequeue();
		layoutQueue.enqueue(layoutState);
	}
}
Beispiel #9
0
void CIDragon::ProcessMovingKeys() {
    CVec newDir = getDir();
    S_WormSettings settings;
    settings = (g_pSettings->s.WormSet[getOwner()->getWormID()]);
    //TODO senseless to handle it with pointer!^^

    //Jumping = Flying
    if (g_pFramework->KeyDown(settings.KeyJump)) { //Jump!
        newDir.y = DRAGONJUMPSPEED_Y;
    }

    //Left or Right!!
    if (g_pFramework->KeyDown(settings.KeyLeft) == true) {
        newDir.x += -DRAGONACCELERATION;
        if (newDir.x < -DRAGONMAXSPEED_X) newDir.x = -DRAGONMAXSPEED_X;
    } else if (g_pFramework->KeyDown(settings.KeyRight) == true ) {
        newDir.x += +DRAGONACCELERATION;
        if (newDir.x > DRAGONMAXSPEED_X) newDir.x = DRAGONMAXSPEED_X;
    }

    setDir(newDir);
}
Beispiel #10
0
DECLARE_EXPORT PyObject* Item::getattro(const Attribute& attr)
{
  if (attr.isA(Tags::tag_name))
    return PythonObject(getName());
  if (attr.isA(Tags::tag_description))
    return PythonObject(getDescription());
  if (attr.isA(Tags::tag_category))
    return PythonObject(getCategory());
  if (attr.isA(Tags::tag_subcategory))
    return PythonObject(getSubCategory());
  if (attr.isA(Tags::tag_price))
    return PythonObject(getPrice());
  if (attr.isA(Tags::tag_owner))
    return PythonObject(getOwner());
  if (attr.isA(Tags::tag_operation))
    return PythonObject(getOperation());
  if (attr.isA(Tags::tag_hidden))
    return PythonObject(getHidden());
  if (attr.isA(Tags::tag_members))
    return new ItemIterator(this);
  return NULL;
}
void Collision::update(float delta){
    parent = (CCNode*)getOwner();
    if (!parent) {
        return;
    }
    
    if (bird->status == isDie) {
        return;
    }
    //printf("getWorldPosition...%f\n", getWorldPosition().x);
    if (getScore) {
        if (getWorldPosition().x <= bird->getPosition().x) {

            getScore = false;
            bird->updateScore();
        }
    }
    
    if (isCollision()) {
        bird->hit();
    }
}
Beispiel #12
0
void LevelController::onThink(const float dt)
{
    m_spawnTimer += dt;
    
    if(m_spawnTimer > m_spawnRate)
    {
        m_spawnTimer = 0;
        
        CaffEnt::Entity *ship = getOwner().getState()->pushNewEntity("EnemyBreederShip");
        
        if(ship)
        {
            VortexTransform *transform = ship->getComponent<VortexTransform>();
            assert(transform);
            
            transform->setAngle(CaffMath::RandFloatRange(0.f, CaffMath::Tau()));
            transform->setDepth(transform->getFarZone());
            
            ++m_numberOfEnemyShips;
        }
    }
}
Beispiel #13
0
void CvSelectionGroupAI::AI_separateImpassable()
{
	CLLNode<IDInfo>* pEntityNode;
	CvUnit* pLoopUnit;
	CvPlayerAI& kPlayer = GET_PLAYER(getOwner());

	pEntityNode = headUnitNode();

	while (pEntityNode != NULL)
	{
		pLoopUnit = ::getUnit(pEntityNode->m_data);
		pEntityNode = nextUnitNode(pEntityNode);
		if( (kPlayer.AI_unitImpassableCount(pLoopUnit->getUnitType()) > 0) )
		{
			pLoopUnit->joinGroup(NULL);
			if (pLoopUnit->plot()->getTeam() == getTeam())
			{
				pLoopUnit->getGroup()->pushMission(MISSION_SKIP);
			}
		}
	}
}
void GhostManager::flushScopeAlwaysObjects()
{
   scopeAlwaysList.sort();

   SortableVector<AddListEntry>::iterator i;
   for(i = scopeAlwaysList.begin(); i != scopeAlwaysList.end(); i++)
   {
      if(!manager->registerObject((*i).obj))
      {
         if(!getLastError()[0])
            setLastError("Invalid packet.");
         return;
      }
      cleanupGroup->addObject((*i).obj);
      if((*i).obj->netFlags.test(SimNetObject::PolledGhost))
         owner->getEventManager()->addPolledObject((*i).obj);
   }
   scopeAlwaysList.clear();
   CSDelegate *delegate = (CSDelegate *) manager->findObject(SimCSDelegateId);
   if(delegate)
      delegate->onGhostAlwaysDone(getOwner());
}
Beispiel #15
0
//------------------------------------------------------------------------------
bool TankMine::collisionCallback(const physics::CollisionInfo & info)
{
    // early bail out on coll. with static
    if(info.type_ != physics::CT_START || info.other_geom_->isStatic()) return true;

    assert((TankMine*)info.this_geom_ ->getUserData() == this);
    
    RigidBody * other = (RigidBody*)info.other_geom_->getUserData();
    
    if(other->getType() == "Tank")
    {
        Tank * tank = (Tank*)other;

        unsigned damage = s_params.get<unsigned>(section_ + ".damage");

        // we can hit ourselves with splash damage, damage to self is
        // always afflicted by UNASSIGNED_SYSTEM_ADDRESS
        SystemAddress damage_dealer = getOwner() == tank->getOwner() ? UNASSIGNED_SYSTEM_ADDRESS : getOwner();
        
        tank->dealWeaponDamage(damage, damage_dealer);

        // apply impact impulse when running over a mine
        Vector impulse = this->getTransform().getY();
        impulse.normalize();
        impulse *= s_params.get<float>(section_ + ".impact_impulse");
        tank->getTarget()->addGlobalForceAtGlobalPos(impulse * s_params.get<float>("physics.fps"),
                                                               info.pos_);

        if (tank->getHitpoints() <= 0)
        {
            game_logic_server_->kill(PKT_MINE, tank, damage_dealer);
        }

        explode(tank->getOwner(), WHT_MINE, OHT_TANK);
    } else explode(UNASSIGNED_SYSTEM_ADDRESS, WHT_MINE, OHT_OTHER);
    
    return true;
}
void DM_ExportSimulationDB::run()
{
	if (this->file_name.empty()) {
		return;
	}
	DM::Group* lg = dynamic_cast<DM::Group*>(getOwner());
	int interal_counter = -1;
	if(lg) {
		interal_counter = lg->getGroupCounter();
	}
	DM::Logger(DM::Debug) << interal_counter;

	if ( (interal_counter - 1) % this->steps != 0 && interal_counter != -1 ) {
		return;
	}

	DM::Logger(DM::Debug) << "Start Inster";

	DM::GDALSystem * sys =  (DM::GDALSystem *)this->getInPortData("city");
	if(!sys)
	{
		DM::Logger(DM::Error) << "Something went wrong while getting the data";
		return;
	}
	QString fileName;
	if (interal_counter != -1)
		 fileName = QString::fromStdString(this->file_name) + "_" + QString::number(interal_counter) + ".sqlite";
	else
		 fileName = QString::fromStdString(this->file_name) + ".sqlite";
	DM::Logger(DM::Standard) << "Copy file to " << fileName.toStdString();

    if (QFile::exists(fileName)){
        QFile::remove(fileName);
    }

	QFile::copy(QString::fromStdString(sys->getDBID()), fileName);
}
void BulletViewComponent::render()
{
	BulletModelComponent *model = getOwner()->getComponent<BulletModelComponent>();
	assert(model);
	
	//glm::vec3 start = model->getStartPos();
	//glm::vec3 end = start + (model->getDirection() * 10.0f);
	
	//CaffSys::DebugRenderer::DrawLine(start, end, glm::vec3(1,0,1));
	
	// Render the line
	CaffApp::Renderer &renderer = CaffServ::RendererManager();
	CaffSys::Camera   &camera   = CaffServ::CameraManager().getCurrentCamera();
	{
		glm::mat4 startPos;
		startPos = glm::translate(startPos, model->getCurrentPos());
		
		const glm::mat4 v = camera.getViewMat();
		const glm::mat4 p = camera.getProjMat();
		const glm::mat4 wvp = p * v * startPos;
		
		const glm::vec3 color(1, 0, 0);
		const float		length(100.0f);
		
		renderer.reset();
		renderer.setShader(shader);
		renderer.setVertexFormat(vertFmt);
		renderer.setVertexBuffer(vertBuffer);
		renderer.setShaderMatrix44f("wvpMat", &wvp[0][0]);
		renderer.setShader4f("color", &color[0]);
		renderer.setShader3f("direction", &model->getDirection()[0]);
		renderer.setShader1f("tracerLength", &length);
		renderer.apply();
		
		glDrawArrays(GL_POINTS, 0, 1);
	}
}
Beispiel #18
0
		void Item::draw(Graphics2D& g)
		{
			model::Project& proj = getOwner().getProject();
			model::SaveData& lsd = proj.getLSD();
			model::DataBase& ldb = proj.getLDB();

			std::ostringstream ss;
			switch( cursorNum() ) {
				case 1: { // select item
					std::map< uint16_t, model::SaveData::Item >& itemList = lsd.item();
					structure::Array2D const& item = ldb[13];

					g.drawWindow( Vector2D(0,  0), Size2D(SCREEN_SIZE[0], 32) );

					g.drawWindow( Vector2D(0, 32), SCREEN_SIZE - Size2D(0, 32) );
					g.drawCursor(
						Vector2D(4, 42) + Vector2D( cursor() % 2 * 160,  cursor() / 2 * CURSOR_H ),
						Size2D(152, CURSOR_H)
					);
					int index = 0;
					for(std::map< uint16_t, model::SaveData::Item >::const_iterator it = itemList.begin(); it != itemList.end(); ++it) {
						Vector2D base = Vector2D(8, 42) + Vector2D( index % 2 * 160,  index / 2 * CURSOR_H );
						if( cursor() == index ) {
							g.drawString( item[it->first][2], Vector2D(8, 10) );
						}

						g.drawString(item[it->first][1], base);
						ss.str(""); ss << ":" << std::setw(2) << it->second.num;
						g.drawString( ss.str(), base + Vector2D( font::HALF_FONT_W*21, 0 ) );

						index++;
					}
				} break;
				case 2: // select char
					break;
			}
		}
Beispiel #19
0
void MagicField::onStepInField(const CreatureP& creature)
{
	if(getId() == ITEM_MAGICWALL_SAFE || getId() == ITEM_WILDGROWTH_SAFE || isBlocking(creature.get()))
	{
		if(!creature->isGhost())
			server.game().internalRemoveItem(creature.get(), this, 1);

		return;
	}

	if(!getKind()->condition)
		return;

	Condition* condition = getKind()->condition->clone();
	uint32_t ownerId = getOwner();
	if(ownerId && !getTile()->hasFlag(TILESTATE_PVPZONE))
	{
		if(auto owner = server.world().getCreatureById(ownerId))
		{
			bool harmful = true;
			if((server.game().getWorldType() == WORLD_TYPE_NO_PVP || getTile()->hasFlag(TILESTATE_NOPVPZONE))
				&& (owner->getPlayer() || owner->hasController()))
				harmful = false;
			else if(Player* targetPlayer = creature->getPlayer())
			{
				if(owner->getPlayer() && Combat::isProtected(owner->getPlayer(), targetPlayer))
					harmful = false;
			}

			if(!harmful || (OTSYS_TIME() - createTime) <= (uint32_t)server.configManager().getNumber(
				ConfigManager::FIELD_OWNERSHIP) || creature->hasBeenAttacked(ownerId))
				condition->setParam(CONDITIONPARAM_OWNER, ownerId);
		}
	}

	creature->addCondition(condition);
}
//
// Approximate how many turns this group would take to reduce pCity's defense modifier to zero
//
int CvSelectionGroup::getBombardTurns(CvCity* pCity)
{
	PROFILE_FUNC();

	bool bHasBomber = (area()->getNumAIUnits(getOwner(),UNITAI_ATTACK_AIR) > 0);
	bool bIgnoreBuildingDefense = bHasBomber;
	int iTotalBombardRate = (bHasBomber ? 16 : 0);

	CLLNode<IDInfo>* pUnitNode = headUnitNode();
	while (pUnitNode != NULL)
	{
		CvUnit* pLoopUnit = ::getUnit(pUnitNode->m_data);
		pUnitNode = nextUnitNode(pUnitNode);

		if( pLoopUnit->bombardRate() > 0 )
		{
			iTotalBombardRate += pLoopUnit->bombardRate();
			bIgnoreBuildingDefense = (bIgnoreBuildingDefense || pLoopUnit->ignoreBuildingDefense());
		}
	}

	int iBombardTurns = pCity->getDefenseModifier(bIgnoreBuildingDefense);
	if( !bIgnoreBuildingDefense )
	{
		iBombardTurns *= 100;
		iBombardTurns /= std::max(25, (100 - pCity->getBuildingBombardDefense()));
	}
	iBombardTurns /= std::max(8, iTotalBombardRate);

	// added Sephi
	if (iTotalBombardRate==0)
	{
		return -1;
	}

	return iBombardTurns;
}
Beispiel #21
0
/*!
	Displays interface information to an output stream

	\param[in] out is the output stream
	\param[in] indent is the number of trailing spaces to prepend when
	writing the information
*/
void Interface::display(std::ostream &out, unsigned short int indent) const
{
	std::string t_s = std::string(indent, ' ');

	// If the type is unknown there are no information to display
	if (getType() == ElementInfo::UNDEFINED) {
	    out << t_s << "interface type:    (unknown)" << std::endl;
	    return;
	}

	// General info ----------------------------------------------------- //
	out << t_s << "interface type: " << getType() << std::endl;
	out << t_s << "ID:             " << getId() << std::endl;
	out << t_s << "is border:      ";
	if (getNeigh() >= 0)  { out << "(false)"; }
	else                  { out << "(true)"; }
	out << std::endl;

	// Connectivity infos --------------------------------------------------- //
	int nVertices = getVertexCount();
	out << t_s << "connectivity: [ ";
	for (int i = 0; i < nVertices - 1; ++i) {
		out << getVertex(i) << ", ";
	} //next i
	out << getVertex(nVertices - 1) << " ]" << std::endl;

	// Onwer infos ---------------------------------------------------------- //
	out << t_s << "onwer ID:    " << getOwner() << std::endl;
	out << t_s << "owner face:  " << getOwnerFace() << std::endl;

	// Onwer infos ---------------------------------------------------------- //
	if (getNeigh() >= 0) {
		out << t_s << "neighbour ID:    " << getNeigh() << std::endl;
		out << t_s << "neighbour face:  " << getNeighFace() << std::endl;
	}
}
Beispiel #22
0
		void Skill::run(input::KeyListener& keyList)
		{
			if( cursorCountLeft() ) return;

			switch( cursorNum() ) {
				case 2: // select skill
					if( keyList.cancel() ) removeLastCursor(); // skip return to source char select
					switch( keyList.getCursor() ) {
						case Key::UP   :  --cursor(); decCursor(); break;
						case Key::RIGHT: incCursor(); break;
						case Key::LEFT : decCursor(); break;
						case Key::DOWN :  ++cursor(); incCursor(); break;
						default: break;
					}
					break;
				case 3:  // select destination char
					break;
			}

			if( keyList.cancel() ) {
				if( cursorNum() <= 2 ) getOwner().returnGameMode();
				else removeLastCursor();
			}
		}
void CBirdCommander::update(float delta)
{
    CCommander::update(delta);
    
    CGameObject* pOwner = dynamic_cast<CGameObject*>(getOwner());
    
    switch (pOwner->getCurrentState()) {
        case CBird::ST_IDLE:
        {
            m_fDelayTime += delta;
            
            if(m_fDelayTime >= random(5, 15))
            {
                m_fDelayTime = 0;
                
                Value command(CBird::CMD_MOVE);
                
                m_pOwner->actionCommand(command);
            }
        }break;
        default:
            break;
    }
}
void gkGhost::destroy(void)
{
	GK_ASSERT(m_object);

	btDynamicsWorld* dyn = getOwner();


	if (m_collisionObject)
	{
		// intertwine
		m_collisionObject->setUserPointer(0);

		if (!m_suspend)
			dyn->removeCollisionObject(m_collisionObject);

		delete m_shape;
		m_shape = 0;

		delete m_collisionObject;

		m_collisionObject = 0;
	}

}
void PlayerModelComponent::onAttach()
{
	// -- Phys
	
	CaffComp::PhysicsComponent *phys = getOwner()->getRigidBody();
		
	phys->setMass(9);

	const CaffSys::ModelData &collisonMesh = CaffServ::ModelManager().getModelData("SpitfireCollision");
	CaffApp::Mesh &mesh = collisonMesh.model->getMesh(0);
	
	btTriangleMesh *bulletMesh = new btTriangleMesh();

	// TODO: EEEEK I had to go into blender to get the number of tri's
	for(uint16_t i = 0; i < 26; ++i)
	{
		CaffApp::VertexContainer verts = mesh.getGLVertexBuffer();
		
		uint16_t vertA = (i * (8 * 3)) + (8 * 0);
		btVector3 a(verts[vertA + 0], verts[vertA + 1], verts[vertA + 2]);

		uint16_t vertB = (i * (8 * 3)) + (8 * 1);
		btVector3 b(verts[vertB + 0], verts[vertB + 1], verts[vertB + 2]);
		
		uint16_t vertC = (i * (8 * 3)) + (8 * 2);
		btVector3 c(verts[vertC + 0], verts[vertC + 1], verts[vertC + 2]);
		
		bulletMesh->addTriangle(a, b, c, false);
	}
	
	btConvexTriangleMeshShape* shape = new btConvexTriangleMeshShape(bulletMesh);
	
	//phys->setCollisionShape(shape);
	//std::unique_ptr<CaffComp::Collider> collider(new CaffComp::BoxCollider(1.f, 1.f, 2.f));
	//phys->setColliderShape(std::move(collider));
}
Beispiel #26
0
void VortexCamera::onThink(const float dt)
{
	CaffComp::TransformComponent *transform = getOwner().getComponent<CaffComp::TransformComponent>();
	assert(transform);

	// update position
	{
		const float changeRate = m_rateChange * dt;
	
		const CaffMath::Vector3 direction = CaffMath::Vector3ComponentSubtract(m_targetPosition, transform->getPosition());
		const CaffMath::Vector3 change	  = CaffMath::Vector3Scale(direction, changeRate);
		const CaffMath::Vector3 newPos	  = CaffMath::Vector3ComponentAdd(transform->getPosition(), change);
	
		transform->setPosition(newPos);
	}
	
	// Set Rotation
	// TODO: Double check this math.
	{
		const CaffMath::Vector3 up          = CaffMath::Vector3Init(0, 1, 0);
		const CaffMath::Vector3 lookatDir   = CaffMath::Vector3ComponentSubtract(m_targetLookAt, transform->getPosition());
		
		const CaffMath::Vector3 UCrossL     = CaffMath::Vector3CrossProduct(up, lookatDir);
		const CaffMath::Vector3 UCrossLNorm = CaffMath::Vector3Normalize(UCrossL);
		
		const float targetPosLen            = CaffMath::Vector3Magnitude(up);
		const float targetLookAtLen         = CaffMath::Vector3Magnitude(lookatDir);
		
		const float w = CaffMath::SquareRoot((targetPosLen * targetPosLen) * (targetLookAtLen * targetLookAtLen)) + CaffMath::Vector3DotProduct(up, lookatDir);
		
		const CaffMath::Quaternion rotation = CaffMath::QuaternionInit(w, UCrossLNorm.x, UCrossLNorm.y, UCrossLNorm.z);
		const CaffMath::Quaternion rotNorm  = CaffMath::QuaternionNormalize(rotation);
		
		transform->setRotation(rotNorm);
	}
}
Beispiel #27
0
void PressureDoor::doSolve() {
	if (_playingAgainstRobot) {
		GameState.setNoradSubRoomPressure(11);
		_levelsMovie.setTime((11 + kPressureBase) * _levelsScale);
		_levelsMovie.redrawMovieWorld();
		_typeMovie.setSegment(kMaxPressureLoopStart * _typeScale, kMaxPressureLoopStop * _typeScale);
		_typeMovie.setFlags(kLoopTimeBase);
		_typeMovie.show();
		_typeMovie.start();
		g_AIArea->checkMiddleArea();
	} else {
		GameState.setNoradSubRoomPressure(kNormalSubRoomPressure);
		_levelsMovie.setTime((kNormalSubRoomPressure + kPressureBase) * _levelsScale);
		_levelsMovie.redrawMovieWorld();
		_typeMovie.setSegment(kOpeningDoorLoopStart * _typeScale, kOpeningDoorLoopStop * _typeScale);
		_typeMovie.setFlags(kLoopTimeBase);
		_typeMovie.show();
		Neighborhood *owner = getOwner();
		owner->requestDelay(2, 1, kFilterNoInput, kDelayCompletedFlag);
		_gameState = kPlayingDoneMessage;
		_typeMovie.start();
		g_AIArea->checkMiddleArea();
	}
}
Variant ThreadSharedVariant::toLocal() {
  ASSERT(getOwner());
  switch (m_type) {
  case KindOfBoolean:
    {
      return (bool)m_data.num;
    }
  case KindOfInt64:
    {
      return m_data.num;
    }
  case KindOfDouble:
    {
      return m_data.dbl;
    }
  case KindOfString:
    {
      if (m_data.str->isStatic()) return m_data.str;
      return NEW(StringData)(this);
    }
  case KindOfArray:
    {
      if (getSerializedArray()) {
        return apc_unserialize(String(m_data.str->data(), m_data.str->size(),
                                      AttachLiteral));
      }
      return NEW(SharedMap)(this);
    }
  default:
    {
      ASSERT(m_type == KindOfObject);
      return apc_unserialize(String(m_data.str->data(), m_data.str->size(),
                                    AttachLiteral));
    }
  }
}
Beispiel #29
0
void ComponentDrawCamera::draw (CameraObject* camera)
{
    CameraObject *placeable = checkedCast<CameraObject*>(getOwner());
    if (!placeable)
        return;
        
    _line_material.setBlendEnable(false);
    _line_material.setDepthEnable(true);
    _line_material.setCullMode(DT3GL_CULL_NONE);
    _line_material.setColor(_color);
	_line_material.setShader(ShaderResource::getShader(FilePath("{editorline.shdr}")));


    DrawBatcher b;
    b.batchBegin(&_line_material, placeable->getTransform(), DrawBatcher::BATCH_LINES, DrawBatcher::FMT_V);

    // Can
    for (DTuint i = 0; i < ARRAY_SIZE(can); ++i) {        
        b.vertex( Vector3(THICKNESS, can[i].x, can[i].y) );
        b.vertex( Vector3(-THICKNESS, can[i].x, can[i].y) );
    }

    for (DTuint i = 0; i < ARRAY_SIZE(can)-1; ++i) {        
        b.vertex( Vector3(THICKNESS, can[i].x, can[i].y) );
        b.vertex( Vector3(THICKNESS, can[i+1].x, can[i+1].y) );
        
        b.vertex( Vector3(-THICKNESS, can[i].x, can[i].y) );
        b.vertex( Vector3(-THICKNESS, can[i+1].x, can[i+1].y) );
    }
    
    // Box
    for (DTuint i = 0; i < ARRAY_SIZE(box); ++i) {        
        b.vertex( Vector3(THICKNESS, box[i].x, box[i].y) );
        b.vertex( Vector3(-THICKNESS, box[i].x, box[i].y) );
    }

    for (DTuint i = 0; i < ARRAY_SIZE(box)-1; ++i) {        
        b.vertex( Vector3(THICKNESS, box[i].x, box[i].y) );
        b.vertex( Vector3(THICKNESS, box[i+1].x, box[i+1].y) );
        
        b.vertex( Vector3(-THICKNESS, box[i].x, box[i].y) );
        b.vertex( Vector3(-THICKNESS, box[i+1].x, box[i+1].y) );
    }

    // Side
    for (DTuint i = 0; i < ARRAY_SIZE(side); ++i) {        
        b.vertex( Vector3(THICKNESS, side[i].x, side[i].y) );
        b.vertex( Vector3(SIDE_THICKNESS+THICKNESS, side[i].x, side[i].y) );
    }

    for (DTuint i = 0; i < ARRAY_SIZE(side)-1; ++i) {        
        b.vertex( Vector3(THICKNESS, side[i].x, side[i].y) );
        b.vertex( Vector3(THICKNESS, side[i+1].x, side[i+1].y) );
        
        b.vertex( Vector3(SIDE_THICKNESS+THICKNESS, side[i].x, side[i].y) );
        b.vertex( Vector3(SIDE_THICKNESS+THICKNESS, side[i+1].x, side[i+1].y) );
    }
    
    // Lens
    for (DTuint i = 0; i < ARRAY_SIZE(lens); ++i) {        
        b.vertex( Vector3(LENS_THICKNESS, lens[i].x, lens[i].y) );
        b.vertex( Vector3(-LENS_THICKNESS, lens[i].x, lens[i].y) );
    }

    for (DTuint i = 0; i < ARRAY_SIZE(lens)-1; ++i) {        
        b.vertex( Vector3(LENS_THICKNESS, lens[i].x, lens[i].y) );
        b.vertex( Vector3(LENS_THICKNESS, lens[i+1].x, lens[i+1].y) );
        
        b.vertex( Vector3(-LENS_THICKNESS, lens[i].x, lens[i].y) );
        b.vertex( Vector3(-LENS_THICKNESS, lens[i+1].x, lens[i+1].y) );
    }
    
    b.batchEnd();
	b.flush();

    // Frustum
    
	placeable->calculateFrustum();
	Matrix4 projection_inv = placeable->getProjection().inversed();
	
	Vector3 near_p0, near_p1, near_p2, near_p3;
	Vector3 far_p0, far_p1, far_p2, far_p3;
	
	MATTransform4H(projection_inv, Vector3(-1.0F,-1.0F,-1.0F), near_p0);
	MATTransform4H(projection_inv, Vector3(1.0F,-1.0F,-1.0F), near_p1);
	MATTransform4H(projection_inv, Vector3(1.0F,1.0F,-1.0F), near_p2);
	MATTransform4H(projection_inv, Vector3(-1.0F,1.0F,-1.0F), near_p3);
	
	MATTransform4H(projection_inv, Vector3(-1.0F,-1.0F,1.0F), far_p0);
	MATTransform4H(projection_inv, Vector3(1.0F,-1.0F,1.0F), far_p1);
	MATTransform4H(projection_inv, Vector3(1.0F,1.0F,1.0F), far_p2);
	MATTransform4H(projection_inv, Vector3(-1.0F,1.0F,1.0F), far_p3);

	b.batchBegin (&_line_material, placeable->getTransform(), DrawBatcher::BATCH_LINE_LOOP, DrawBatcher::FMT_V);
	b.vertex ( near_p0);
	b.vertex ( near_p1);
	b.vertex ( near_p2);
	b.vertex ( near_p3);
	b.batchEnd();
	b.flush();
	
	b.batchBegin (&_line_material, placeable->getTransform(), DrawBatcher::BATCH_LINE_LOOP, DrawBatcher::FMT_V);
	b.vertex ( far_p0);
	b.vertex ( far_p1);
	b.vertex ( far_p2);
	b.vertex ( far_p3);
	b.batchEnd();
	b.flush();
	
	b.batchBegin (&_line_material, placeable->getTransform(), DrawBatcher::BATCH_LINE_LOOP, DrawBatcher::FMT_V);
	b.vertex ( near_p0);
	b.vertex ( near_p1);
	b.vertex ( far_p1);
	b.vertex ( far_p0);
	b.batchEnd();
	b.flush();
	
	b.batchBegin (&_line_material, placeable->getTransform(), DrawBatcher::BATCH_LINE_LOOP, DrawBatcher::FMT_V);
	b.vertex ( near_p2);
	b.vertex ( near_p3);
	b.vertex ( far_p3);
	b.vertex ( far_p2);
	b.batchEnd();	
	b.flush();

    

}
Beispiel #30
0
Resource* AnimationManager::createResource(const Path& path)
{
	return m_allocator.newObject<Animation>(path, getOwner(), m_allocator);
}