//========================================================= // Crea un hijo en un nodo candidato. //========================================================= void CDirector_Manager::AddChild() { // Actualizamos los nodos candidatos para la creación. UpdateNodes(); // ¡No hay nodos! if ( SpawnNodes.Count() <= 0 ) return; // Intentamos crear al hijo. for ( int i = 0; i < MAX_TRIES; ++i ) { // Seleccionamos un nodo candidato al azar. CAI_Node *pNode = GetRandomNode(); // El nodo no existe. if ( !pNode ) continue; // Obtenemos la ubicación del nodo e intentamos crear al hijo. Vector vecOrigin = pNode->GetPosition(HULL_HUMAN); bool bSpawn = AddChild(vecOrigin); // El hijo no se ha podido crear. if ( !bSpawn ) continue; // Un hijo menos en la cola. Director()->SpawnQueue = Director()->SpawnQueue - 1; break; } }
void TurretManager::UpdateTurrets(float deltaTime, EnemyManager* enemyManager) { std::vector<std::shared_ptr<uth::GameObject>> nearbyEnemies; UpdateNodes(); for (int i = turrets.size() - 1; i >= 0; i--) { auto& turret = *turrets[i]; auto& c = *turret.GetComponent<Turret>(); if (c.GetOrbit() == 1) turret.transform.SetPosition(cosf(orbit01Angle + c.GetOrbitPos()*(pmath::pi / 3 / c.GetOrbit())) * 115 * c.GetOrbit(), sinf(orbit01Angle + c.GetOrbitPos()*(pmath::pi / 3 / c.GetOrbit())) * 115 * c.GetOrbit()); else if (c.GetOrbit() == 2) turret.transform.SetPosition(cosf(orbit02Angle + c.GetOrbitPos()*(pmath::pi / 3 / c.GetOrbit())) * 115 * c.GetOrbit(), sinf(orbit02Angle + c.GetOrbitPos()*(pmath::pi / 3 / c.GetOrbit())) * 115 * c.GetOrbit()); float turretPositionX = turret.transform.GetPosition().x; float turretPositionY = turret.transform.GetPosition().y; c.SetCooldown(c.GetCooldown() + deltaTime); nearbyEnemies = EnemyWithinRange(enemyManager, turretPositionX, turretPositionY, c.GetRange()); if (nearbyEnemies.size() > 0) { turret.transform.SetRotation(pmath::radiansToDegrees(atan2f(nearbyEnemies[0]->transform.GetPosition().y - turretPositionY, nearbyEnemies[0]->transform.GetPosition().x - turretPositionX))); if (c.CanShoot()) { //ShootBullet(turretPositionX, turretPositionY, atan2f(nearbyEnemies[0]->transform.GetPosition().y - turretPositionY, nearbyEnemies[0]->transform.GetPosition().x - turretPositionX), c.GetBulletSpeed(), c.GetDamage(), c.GetRange(), c.GetAoe(),c.GetPenetrate(),c.GetSlowAmount(),c.GetCrit(),c.GetPenetrate(),c.GetTexture()); ShootBullet(turretPositionX, turretPositionY, atan2f(nearbyEnemies[0]->transform.GetPosition().y - turretPositionY, nearbyEnemies[0]->transform.GetPosition().x - turretPositionX), c); } } } }
//========================================================= // Crea un jefe. //========================================================= void CDirector_Manager::SpawnBoss() { // Actualizamos los nodos candidatos para la creación. UpdateNodes(); // ¡No hay nodos! if ( SpawnNodes.Count() <= 0 ) return; for ( int i = 0; i < MAX_TRIES; ++i ) { // Seleccionamos un nodo candidato al azar. CAI_Node *pNode = GetRandomNode(); // El nodo no existe. if ( !pNode ) continue; // Obtenemos la ubicación del nodo. Vector vecOrigin = pNode->GetPosition(HULL_MEDIUM_TALL); bool bSpawn = AddBoss(vecOrigin); // El hijo no se ha podido crear. if ( !bSpawn ) continue; return; } // No se pudo crear al Jefe, intentarlo en otro momento. Director()->BossPendient = true; }
void CAnimationGroupEditImp::ActiveNode( CRenderNode* pNode ) { if (IsNodesChanged()) { UpdateNodes(); CCtrlBase::Update(); } else if (m_pModel != EDITMODEL) { m_pModel = EDITMODEL; if (!m_strCurAgpName.empty()) { m_CurAni = NULL; m_pSkeletalFrame = NULL; m_pAnimateGroup = NULL; AddAgp(m_strCurAgpName); } } }
//========================================================= // Crea un bonche de hijos en un nodo candidato. //========================================================= void CDirector_Manager::AddHorde(int pMount) { // Actualizamos los nodos candidatos para la creación. UpdateNodes(); // ¡No hay nodos! if ( SpawnNodes.Count() <= 0 ) return; for ( int i = 0; i < MAX_TRIES; ++i ) { // Seleccionamos un nodo candidato al azar. CAI_Node *pNode = GetRandomNode(); // El nodo no existe. if ( !pNode ) continue; // Obtenemos la ubicación del nodo. Vector vecOrigin = pNode->GetPosition(HULL_HUMAN); ConVarRef director_debug("director_debug"); if ( director_debug.GetBool() ) NDebugOverlay::Cross3D(vecOrigin, 50.0f, 255, 128, 0, true, 20.0f); // Creamos varios hijos en este nodo. // Con las colisiones especiales (No colisionan con los otros hijos) for ( int h = 0; h < pMount; ++h ) { for ( int s = 0; s < MAX_TRIES; ++s ) { bool pSpawn = AddChild(vecOrigin, SPAWN_NO_COLLISION_AND_POWERFUL); if ( pSpawn ) break; } } break; } }
void CTopClauses::NewClause(CClauseNode* pNode1, CClauseNode* pNode2, SClauseFuncArg& arg) { //try { CClause* clause1 = pNode1->GetMainClause(); CClause* clause2 = pNode2->GetMainClause(); bool clause1WordsCountZero = (clause1->m_ClauseWords.size() == 0); bool clause2WordsCountZero = (clause2->m_ClauseWords.size() == 0); bool bIncludeOp = clause1WordsCountZero || clause2WordsCountZero; CClauseNode* pClonedNode1 = NULL; CClauseNode* pClonedNode2 = NULL; if (!bIncludeOp) { int size1 = pNode1->m_outNodes.size(); int size2 = pNode2->m_inNodes.size(); if (size1 > 1) pClonedNode1 = pNode1->Clone(); if (size2 > 1) pClonedNode2 = pNode2->Clone(); if (arg.m_iClause2TypeNum != -1) clause2->AddValsToType(arg.m_NewValencies2, arg.m_iClause2TypeNum); } if (clause1WordsCountZero) { arg.m_bMainFirst = true; IncludeClause(pNode1, pNode2, arg); pNode1->GetMainClause()->RunSynAn(); return; } if (clause2WordsCountZero) { arg.m_bMainFirst = false; IncludeClause(pNode1, pNode2, arg); pNode2->GetMainClause()->RunSynAn(); return; } CClause* pNewClause = CClause::Create(m_Words); pNewClause->SetPair(clause1->FirstWord(), clause2->LastWord()); if (arg.m_bMainFirst) pNewClause->m_Types = clause1->m_Types; else pNewClause->m_Types = clause2->m_Types; pNewClause->AddBadWeight(arg.m_BadWeight); pNewClause->m_Conjs = clause1->m_Conjs; //if( arg.m_BadWeightForCommas > 0 ) // pNewClause->m_BadCommas.push_back(SBadComma(clause1->LastWord(), arg.m_BadWeightForCommas) ); //MultiplyBadCommaWeight(*pNewClause, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); pNewClause->AddBadComma(clause1->LastWord(),arg.m_BadWeightForCommas, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); //pNewClause->m_BadWeightForCommas += arg.m_BadWeightForCommas; //pNewClause->m_BadWeightForCommas *= arg.m_CoefficientToIncreaseBadWeightForCommas; pNode1->m_pClauseTree->AddSubClauses(pNode2->m_pClauseTree, pNewClause); pNode1->GetMainClause()->RunSynAn(); UpdateNodes(pNode1, pNode2, pClonedNode1, pClonedNode2, true); } /*catch(...) { ythrow yexception() << "Error in \"CTopClauses::NewClause\""; }*/ }
void CTopClauses::IncludeClause(CClauseNode* pNode1, CClauseNode* pNode2, SClauseFuncArg& arg) { //try { CClause* clause1 = pNode1->GetMainClause(); CClause* clause2 = pNode2->GetMainClause(); CClauseNode* pClonedNode1 = NULL; CClauseNode* pClonedNode2 = NULL; int size1 = pNode1->m_outNodes.size(); int size2 = pNode2->m_inNodes.size(); if (size1 > 1) pClonedNode1 = pNode1->Clone(); if (size2 > 1) pClonedNode2 = pNode2->Clone(); if (arg.m_iClause2TypeNum != -1) //если вызывается из NewClause AddValsToSubClauses(pNode2, arg); //clause2->AddValsToType(arg.m_NewValencies2, arg.m_iClause2TypeNum); if (arg.m_bMainFirst) { pNode1->m_pClauseTree->EraseMainClause(); clause1->SetLastWord(clause2->LastWord()); if (arg.m_ConjSupValency.IsValid() && (arg.m_iConj != -1)) clause2->m_Conjs[arg.m_iConj].m_SupVal = arg.m_ConjSupValency; if (arg.m_NodeSupValency.IsValid() && (arg.m_iClause2TypeNum != -1)) clause2->GetType(arg.m_iClause2TypeNum).m_SupVal = arg.m_NodeSupValency; clause1->AddBadWeight(arg.m_BadWeight); //if( arg.m_BadWeightForCommas > 0 ) // clause1->m_BadCommas.push_back(SBadComma(clause1->LastWord(), arg.m_BadWeightForCommas) ); //MultiplyBadCommaWeight(*clause1, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); clause1->AddBadComma(clause1->LastWord(),arg.m_BadWeightForCommas, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); //clause1->m_BadWeightForCommas += arg.m_BadWeightForCommas; //clause1->m_BadWeightForCommas *= arg.m_CoefficientToIncreaseBadWeightForCommas; pNode1->m_pClauseTree->AddSubClauses(pNode2->m_pClauseTree, clause1); } else { clause2->AddBadWeight(arg.m_BadWeight); pNode2->m_pClauseTree->EraseMainClause(); clause2->SetFirstWord(clause1->FirstWord()); /*if( arg.m_ConjSupValency.IsValid() && (arg.m_iConj != -1) ) clause2->m_Conjs[arg.m_iConj].m_Sup Val = arg.m_ConjSupValency;*/ //if( arg.m_BadWeightForCommas > 0 ) // clause2->m_BadCommas.push_back(SBadComma(clause1->LastWord(), arg.m_BadWeightForCommas) ); //MultiplyBadCommaWeight(*clause2, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); clause2->AddBadComma(clause1->LastWord(),arg.m_BadWeightForCommas, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); //clause2->m_BadWeightForCommas += arg.m_BadWeightForCommas; //clause2->m_BadWeightForCommas *= arg.m_CoefficientToIncreaseBadWeightForCommas; pNode2->m_pClauseTree->AddSubClauses(pNode1->m_pClauseTree, clause2); } UpdateNodes(pNode1, pNode2, pClonedNode1, pClonedNode2, arg.m_bMainFirst); } /*catch(...) { ythrow yexception() << "Error in \"CTopClauses::IncludeClause\""; }*/ }
void CTopClauses::UniteClause(CClauseNode* pNode1, CClauseNode* pNode2, SClauseFuncArg& arg) { CClause* pCl1 = pNode1->GetMainClause(); CClause* pCl2 = pNode2->GetMainClause(); Stroka strStage = "Stage0 "; //try { CClauseNode* pClonedNode1 = NULL; CClauseNode* pClonedNode2 = NULL; int size1 = pNode1->m_outNodes.size(); int size2 = pNode2->m_inNodes.size(); if (size1 > 1) pClonedNode1 = pNode1->Clone(); if (size2 > 1) pClonedNode2 = pNode2->Clone(); if (!arg.m_bMainFirst) { strStage = "Stage1 "; pNode2->m_pClauseTree->EraseMainClause(); pCl2->AddClauseWords(*pCl1, false); strStage = "Stage2 "; pCl1->ClearConjs(); if (arg.m_iClause2TypeNum != -1) pCl2->AddValsToType(arg.m_NewValencies, arg.m_iClause2TypeNum); strStage = "Stage3 "; if (arg.m_NewType.m_Type != UnknownClause) pCl2->DelAllTypesAndAdd(arg.m_NewType); if (!arg.m_bRefreshClauseInfo) { strStage = "Stage3.1 "; pCl2->RunSynAn(); strStage = "Stage3.2 "; pCl2->RefreshConjInfo(); strStage = "Stage3.3 "; pCl2->RefreshValencies(); strStage = "Stage3.4 "; } else { strStage = "Stage3.5 "; pCl2->RefreshClauseInfo(); strStage = "Stage3.6 "; } strStage = "Stage4 "; pCl2->AddBadWeight(arg.m_BadWeight); pCl2->AddBadWeight(pCl1->m_BadWeight); pCl2->AddBadComma(pCl1->LastWord(),arg.m_BadWeightForCommas, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); strStage = "Stage5 "; //if( arg.m_BadWeightForCommas > 0 ) // pCl2->m_BadCommas.push_back(SBadComma(pCl1->LastWord(), arg.m_BadWeightForCommas) );//m_BadWeightForCommas += arg.m_BadWeightForCommas; //MultiplyBadCommaWeight(*pCl2, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); //pCl2->m_BadWeightForCommas += pCl1->m_BadWeightForCommas; //pCl2->m_BadWeightForCommas *= arg.m_CoefficientToIncreaseBadWeightForCommas; pNode1->m_pClauseTree->EraseMainClause(); strStage = "Stage6 "; delete pCl1;/**/ strStage = "Stage7 "; pNode2->m_pClauseTree->AddSubClauses(pNode1->m_pClauseTree, pCl2); strStage = "Stage8 "; } else { pNode1->m_pClauseTree->EraseMainClause(); pCl1->AddClauseWords(*pCl2); if (arg.m_iClause1TypeNum != -1) pCl1->AddValsToType(arg.m_NewValencies, arg.m_iClause1TypeNum); if (arg.m_NewType.m_Type != UnknownClause) pCl1->DelAllTypesAndAdd(arg.m_NewType); if (!arg.m_bRefreshClauseInfo) { pCl1->RunSynAn(); pCl1->RefreshConjInfo(); } else pCl1->RefreshClauseInfo(); pCl1->AddBadWeight(arg.m_BadWeight); pCl1->AddBadWeight(pCl2->m_BadWeight); //if( arg.m_BadWeightForCommas > 0 ) // pCl1->m_BadCommas.push_back(SBadComma(pCl1->LastWord(), arg.m_BadWeightForCommas) ); pCl1->m_BadCommas.insert(pCl1->m_BadCommas.begin(),pCl2->m_BadCommas.begin(), pCl2->m_BadCommas.end()); pCl1->AddBadComma(pCl1->LastWord(),arg.m_BadWeightForCommas, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); //MultiplyBadCommaWeight(*pCl1, arg.m_PairForBadCoef, arg.m_CoefficientToIncreaseBadWeightForCommas); //pCl1->m_BadWeightForCommas += arg.m_BadWeightForCommas; //pCl1->m_BadWeightForCommas *= arg.m_CoefficientToIncreaseBadWeightForCommas; pNode2->m_pClauseTree->EraseMainClause(); delete pCl2;/**/ pNode1->m_pClauseTree->AddSubClauses(pNode2->m_pClauseTree, pCl1); } UpdateNodes(pNode1, pNode2, pClonedNode1, pClonedNode2, arg.m_bMainFirst); } /*catch(yexception& e) { throw e; } catch(...) { ythrow yexception() << "Error in \"CTopClauses::UniteClause\""; }*/ }