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); }
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; }
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; }
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); } }
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); } }
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); }
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(); } }
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; } } }
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()); }
//------------------------------------------------------------------------------ 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); } }
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; } }
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; }
/*! 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; } }
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)); }
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); } }
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)); } } }
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(); }
Resource* AnimationManager::createResource(const Path& path) { return m_allocator.newObject<Animation>(path, getOwner(), m_allocator); }