bool CRusFormatCaller::format_for_modif_adj_groups (CGroup& G) { if (get_maximal_group_no(G.m_iFirstWord) != -1) return false; int j = G.m_iFirstWord; if( FindInList((const char*)g_strAdjModif, g_AdjModifCount, Wj.get_lemma()) == -1) return false; if( j+1 >= sent.size() ) return false; const CGroup& H = get_maximal_group(j+1); if( !is_morph_adj(sent[H.m_MainWordNo]) ) return false; if( !GetGramTab()->GleicheGenderNumberCase(sent[H.m_MainWordNo].m_type_gram_code, sent[H.m_MainWordNo].m_gramcodes, Wj.m_gramcodes ) ) return false; G.m_iLastWord = H.m_iLastWord; G.m_GroupType = MODIF_ADJ; G.SetGrammems (H.GetGrammems() & sent[j].GetGrammems()); G.m_MainGroup = H; change_words_in_group_grammems(G, G.GetGrammems(), (rAllNumbers | rAllCases)); create_syn_rel(G, H.m_MainWordNo, j , MODIF_ADJ); return true; }
bool CWindowManager::CoreHandleKey(chtype key) { if (CGroup::CoreHandleKey(key)) return true; CWidget *focwidget = GetFocusedWidget(); if (focwidget) { CGroup *focgroup = GetGroupWidget(focwidget); if (focgroup) { if (IsTAB(key)) { if (!focgroup->SetNextFocWidget(true)) focgroup->SetNextFocWidget(false); TUI.UpdateButtonBar(); return true; } else if (key == CTRL('p')) { if (!focgroup->SetPrevFocWidget(true)) focgroup->SetPrevFocWidget(false); TUI.UpdateButtonBar(); return true; } } } return false; }
//--------------------------------------------------------------------------- // @function: // CExpressionHandle::CopyCostCtxtProps // // @doc: // Cache plan properties of cost context and its children on the handle // //--------------------------------------------------------------------------- void CExpressionHandle::CopyCostCtxtProps() { GPOS_ASSERT(NULL != m_pcc); GPOS_ASSERT(NULL == m_pdrgpdp); GPOS_ASSERT(NULL == m_pdp); // add-ref context properties CDrvdProp *pdp = m_pcc->Pdpplan(); pdp->AddRef(); m_pdp = pdp; // add-ref child group expressions' properties const ULONG ulArity = UlArity(); m_pdrgpdp = GPOS_NEW(m_pmp) DrgPdp(m_pmp, ulArity); for (ULONG ul = 0; ul < ulArity; ul++) { CGroup *pgroupChild = (*m_pgexpr)[ul]; if (!pgroupChild->FScalar()) { COptimizationContext *pocChild = (*m_pcc->Pdrgpoc())[ul]; GPOS_ASSERT(NULL != pocChild); CCostContext *pccChild = pocChild->PccBest(); GPOS_ASSERT(NULL != pccChild); pdp = pccChild->Pdpplan(); pdp->AddRef(); m_pdrgpdp->Append(pdp); } } }
CGroup* CMilitary::requestGroup(MilitaryGroupBehaviour type) { CGroup *group = ReusableObjectFactory<CGroup>::Instance(); group->ai = ai; group->reset(); group->reg(*this); LOG_II("CMilitary::requestGroup " << (*group)) switch(type) { case SCOUT: activeScoutGroups[group->key] = group; break; case BOMBER: activeBomberGroups[group->key] = group; break; case ENGAGE: activeAttackGroups[group->key] = group; break; case AIRFIGHTER: activeAirFighterGroups[group->key] = group; break; default: LOG_EE("CMilitary::requestGroup invalid group behaviour: " << type) } return group; }
CGroup* CGroup::FindGroup(const std::string& szName , const int& depth) const { //TODO once we get a depth first traversal func we should use that here int size = this->m_vChildren.size(); for (int i = 0; i < size; ++i) { if (this->m_vChildren[i]->GetName() == szName && this->m_vChildren[i]->IsGroup()) { return dynamic_cast<CGroup*>(this->m_vChildren[i]); } } //If we get here then search our children's children for the object for (int i = 0; i < size; ++i) { if (this->m_vChildren[i]->IsGroup()) { CGroup* pGroup = static_cast<CGroup*>(this->m_vChildren[i]); CGroup* ret = pGroup->FindGroup(szName); if (ret) return ret; } } return null; }
size_t GetRestrictedPhysicalMemoryLimit() { CGroup cgroup; size_t physical_memory_limit; if (!cgroup.GetPhysicalMemoryLimit(&physical_memory_limit)) physical_memory_limit = SIZE_T_MAX; struct rlimit curr_rlimit; size_t rlimit_soft_limit = RLIM_INFINITY; if (getrlimit(RLIMIT_AS, &curr_rlimit) == 0) { rlimit_soft_limit = curr_rlimit.rlim_cur; } physical_memory_limit = (physical_memory_limit < rlimit_soft_limit) ? physical_memory_limit : rlimit_soft_limit; // Ensure that limit is not greater than real memory size long pages = sysconf(_SC_PHYS_PAGES); if (pages != -1) { long pageSize = sysconf(_SC_PAGE_SIZE); if (pageSize != -1) { physical_memory_limit = (physical_memory_limit < (size_t)pages * pageSize)? physical_memory_limit : (size_t)pages * pageSize; } } return physical_memory_limit; }
void getName_c_s(CStateInstance* entity, CScriptStack& stack) { IScriptContext* ctx = (IScriptContext*)stack.top(); CGroup* group = dynamic_cast<CGroup*>(ctx); if (group) stack.top() = group->getName(); else stack.top() = string(); }
bool GetCpuLimit(uint32_t* val) { CGroup cgroup; if (val == nullptr) return false; return cgroup.GetCpuLimit(val); }
void CEconomy::addUnitOnFinished(CUnit &unit) { LOG_II("CEconomy::addUnitOnFinished " << unit) unitCategory c = unit.type->cats; if ((c&BUILDER).any() || ((c&ASSISTER).any() && (c&MOBILE).any())) { CGroup *group = requestGroup(); group->addUnit(unit); } }
CGroup* CEconomy::requestGroup() { CGroup *group = ReusableObjectFactory<CGroup>::Instance(); group->ai = ai; group->reset(); group->reg(*this); activeGroups[group->key] = group; return group; }
BOOL PALAPI PAL_GetCpuLimit(UINT* val) { CGroup cgroup; if (val == nullptr) return FALSE; return cgroup.GetCpuLimit(val); }
void CGroupHandler::GroupCommand(int num, const std::string& cmd) { GML_RECMUTEX_LOCK(grpsel); // GroupCommand CGroup* group = groups[num]; if ((cmd == "set") || (cmd == "add")) { if (cmd == "set") { group->ClearUnits(); } const CUnitSet& selUnits = selectedUnits.selectedUnits; CUnitSet::const_iterator ui; for(ui = selUnits.begin(); ui != selUnits.end(); ++ui) { (*ui)->SetGroup(group); } } else if (cmd == "selectadd") { // do not select the group, just add its members to the current selection CUnitSet::const_iterator ui; for (ui = group->units.begin(); ui != group->units.end(); ++ui) { selectedUnits.AddUnit(*ui); } return; } else if (cmd == "selectclear") { // do not select the group, just remove its members from the current selection CUnitSet::const_iterator ui; for (ui = group->units.begin(); ui != group->units.end(); ++ui) { selectedUnits.RemoveUnit(*ui); } return; } else if (cmd == "selecttoggle") { // do not select the group, just toggle its members with the current selection const CUnitSet& selUnits = selectedUnits.selectedUnits; CUnitSet::const_iterator ui; for (ui = group->units.begin(); ui != group->units.end(); ++ui) { if (selUnits.find(*ui) == selUnits.end()) { selectedUnits.AddUnit(*ui); } else { selectedUnits.RemoveUnit(*ui); } } return; } if ((selectedUnits.selectedGroup == num) && !group->units.empty()) { const float3 groupCenter = group->CalculateCenter(); camHandler->GetCurrentController().SetPos(groupCenter); } selectedUnits.SelectGroup(num); }
void CEconomy::remove(ARegistrar &object) { CGroup *group = dynamic_cast<CGroup*>(&object); LOG_II("CEconomy::remove " << (*group)) activeGroups.erase(group->key); takenMexes.erase(group->key); takenGeo.erase(group->key); group->unreg(*this); ReusableObjectFactory<CGroup>::Release(group); }
void AttackTask::onUpdate() { CGroup *group = firstGroup(); if (group->isMicroing() && group->isIdle()) { targetAlt = -1; // for sure group->micro(false); } if (isMoving) { /* Keep tracking the target */ pos = ai->cbc->GetUnitPos(target); float3 gpos = group->pos(); float dist = gpos.distance2D(pos); float range = group->getRange(); /* See if we can attack our target already */ if (dist <= range) { bool canAttack = true; /* // for ground units prevent shooting across hill... if ((group->cats&AIR).none()) { // FIXME: improve dist = ai->pathfinder->getPathLength(*group, pos); canAttack = (dist <= range * 1.1f); } */ if (canAttack) { if ((group->cats&BUILDER).any()) group->reclaim(target); else group->attack(target); isMoving = false; ai->pathfinder->remove(*group); group->micro(true); } } } /* See if we can attack a target we found on our path */ if (!(group->isMicroing() || urgent())) { if ((group->cats&BUILDER).any()) resourceScan(); // builders should not be too aggressive else enemyScan(targetAlt); } }
bool CGerFormatCaller :: format_for_geo_names (CGroup& G) { size_t j = get_main_word(G.m_iFirstWord); if (!CanBeCityType(Wj)) return false; size_t i = j; if( ++i >= sent.size() ) return false; int main_word = get_main_word(i); if (main_word == -1) return false; if ( !sent[main_word].HasFlag(fl_morph_predicted) && !sent[main_word].has_grammem(gStd) ) return false; G.m_iLastWord = get_maximal_group(i).m_iLastWord; G.m_GroupType = gGEOGR; G.SetGrammems( get_maximal_group(j).GetGrammems() ); G.m_MainGroup = get_maximal_group(j); create_syn_rel(G, j, main_word, gGEOGR); return true; };
// Kanzler Gerhard Schröder // Bundeskanzler Alexey Sokirko // A-Techniker Gerhard Schroder bool CGerFormatCaller :: format_for_rank_fam (CGroup& G) { int i = get_main_word(G.m_iFirstWord); if (!Wi.m_lemma) return false; if ( !Wi.HasFlag(fl_ranknoun) ) return false; size_t j = 0; const CGroup& main_gr = get_maximal_group(G.m_iFirstWord); j = main_gr.m_iLastWord+1; if ( j == sent.size() ) return false; const CGroup& next_gr = get_maximal_group(j); if ( next_gr.m_GroupType!= gFAMILIE_GROUP && next_gr.m_GroupType!= gSPNAME && next_gr.m_GroupType!= gPNAME ) return false; G.m_iLastWord = next_gr.m_iLastWord; G.SetGrammems( Wi.GetGrammems() ); G.m_MainGroup = main_gr; G.m_GroupType = gBERUF_NP; create_syn_rel(G,i,j,gBERUF_NP); return true; };
bool CGroup::CanFocusChilds(CWidget *w) { if (!IsGroupWidget(w)) return false; CGroup *group = GetGroupWidget(w); const TChildList &childs = group->GetChildList(); for (TChildList::const_iterator it=childs.begin(); it!=childs.end(); it++) { if ((*it)->Enabled() && ((*it)->CanFocus() || group->CanFocusChilds(*it))) return true; } return false; }
// Правила для БОЛЕЕ или МЕНЕЕ + прил или кр.прил bool CRusFormatCaller::format_for_anat_compar(CGroup& G) { //более извращенная любительница size_t i = G.m_iFirstWord; const CGroup& MaxGrp = get_maximal_group(i); if (MaxGrp.m_iFirstWord != MaxGrp.m_iLastWord) return false; if ( !Wi.is_word_upper("БОЛЕЕ") && !Wi.is_word_upper("МЕНЕЕ") ) return false; size_t j = i + 1; if (j >= sent.size()) return false; if (get_maximal_group_size(j) != 1) return false; if (is_morph_adj(Wj) || is_morph_participle (Wj)) { G.m_GroupType = ANAT_COMPAR; G.m_iLastWord = j; G.m_MainGroup.m_iFirstWord = j; G.m_MainGroup.m_iLastWord = j; G.SetGrammems( Wj.GetGrammems() ); create_syn_rel(G, j, i, ANAT_COMPAR); return true; } return false; };
bool CRusFormatCaller :: format_for_rank_surname (CGroup& G) { const CGroup& main_gr = get_maximal_group(G.m_iFirstWord); int i = main_gr.m_MainWordNo; if (!Wi.get_lemma()) return false; if ( !Wi.HasFlag(fl_ranknoun) ) return false; size_t j = main_gr.m_iLastWord+1; if ( j == sent.size() ) return false; j = get_main_word(j); if ( !Wj.has_grammem( rSurName ) && !Wj.has_grammem( rName ) ) return false; if ( !GetGramTab()->GleicheCaseNumber(Wi.GetGramcodes(), Wj.GetGramcodes()) ) return false; G.m_iLastWord = get_maximal_group(j).m_iLastWord; G.SetGrammems( Wi.GetGrammems() ); G.m_MainGroup = main_gr; G.m_GroupType = RANK_NAMES; G.m_Cause = "Правила сборки Должность+ФИО"; create_syn_rel(G,i,j,RANK_NAMES); return true; };
void MergeTask::onUpdate() { /* See which groups can be merged already */ std::list<CGroup*>::iterator it; for (it = groups.begin(); it != groups.end(); ++it) { CGroup *g = *it; if (g->isMicroing()) continue; if (pos.distance2D(g->pos()) < range) { mergable[g->key] = g; g->micro(true); } } /* We have at least two groups, now we can merge */ if (mergable.size() >= 2) { std::vector<int> keys; std::map<int, CGroup*>::iterator it; // get keys because while merging "mergable" is reducing... for (it = mergable.begin(); it != mergable.end(); ++it) { keys.push_back(it->first); } for (int i = 0; i < keys.size(); i++) { int key = keys[i]; if (key != masterGroup->key) { CGroup *g = mergable[key]; LOG_II("MergeTask::update merging " << (*g) << " with " << (*masterGroup)) // NOTE: group being merged is automatically removed masterGroup->merge(*g); } } assert(mergable.size() == 1); mergable.clear(); masterGroup->micro(false); } // if only one (or none) group remains, merging is no longer possible, // remove the task, unreg groups... if (groups.size() <= 1) ATask::remove(); }
void AssistTask::onUpdate() { CGroup *group = firstGroup(); if (group->isMicroing() && group->isIdle()) { targetAlt = -1; // for sure group->micro(false); } if (!assisting) { if (isMoving) { /* Keep tracking the target */ pos = assist->pos; float3 gpos = group->pos(); float dist = gpos.distance2D(pos); float range = group->getRange(); if (dist <= range) { bool canAssist = true; /* // for ground units prevent assisting across hill... if ((group->cats&AIR).none()) { dist = ai->pathfinder->getPathLength(*group, pos); canAssist = (dist <= range * 1.1f); } */ if (canAssist) { isMoving = false; ai->pathfinder->remove(*group); } } } if (!isMoving) { group->assist(*assist); group->micro(true); assisting = true; } } if (!group->isMicroing()) { if ((group->cats&BUILDER).any()) resourceScan(); // builders should not be too aggressive else if ((group->cats&AIR).none()) { enemyScan(targetAlt); } } }
bool CMilitary::addUnit(CUnit& unit) { LOG_II("CMilitary::addUnit " << unit) assert(unit.group == NULL); unitCategory c = unit.type->cats; if ((c&ATTACKER).any() && (c&MOBILE).any() && (c&DEFENSE).none()) { unitCategory wishedCats = ai->unittable->unitsUnderConstruction[unit.key]; CGroup* group; if ((c&SCOUTER).any() && wishedCats.any() && (wishedCats&SCOUTER).none()) c &= ~SCOUTER; // scout was not requested if ((c&SCOUTER).any()) { group = requestGroup(SCOUT); } else if((c&AIR).any() && (c&ARTILLERY).any()) { group = requestGroup(BOMBER); } else if((c&AIR).any() && (c&ASSAULT).none()) { group = requestGroup(AIRFIGHTER); } else { /* If there is a new factory, or the current group is busy, request a new group */ std::map<int,CGroup*>::iterator i = assemblingGroups.find(unit.builtBy); if (i == assemblingGroups.end() || i->second->busy || !i->second->canAdd(&unit)) { group = requestGroup(ENGAGE); assemblingGroups[unit.builtBy] = group; } else { group = i->second; } } group->addUnit(unit); return true; } return false; }
//--------------------------------------------------------------------------- // @function: // CGroupExpression::SetOptimizationLevel // // @doc: // Set optimization level of group expression // // //--------------------------------------------------------------------------- void CGroupExpression::SetOptimizationLevel() { // a sequence expression with a first child group that contains a CTE // producer gets a higher optimization level. This is to be sure that the // producer gets optimized before its consumers if (COperator::EopPhysicalSequence == m_pop->Eopid()) { CGroup *pgroupFirst = (*this)[0]; if (pgroupFirst->FHasCTEProducer()) { m_eol = EolHigh; } } else if (CUtils::FHashJoin(m_pop)) { // optimize hash join first to minimize plan cost quickly m_eol = EolHigh; } else if (CUtils::FPhysicalAgg(m_pop)) { BOOL fPreferMultiStageAgg = GPOS_FTRACE(EopttracePreferMultiStageAgg); if (!fPreferMultiStageAgg && COperator::EopPhysicalHashAgg == m_pop->Eopid()) { // if we choose agg plans based on cost only (no preference for multi-stage agg), // we optimize hash agg first to to minimize plan cost quickly m_eol = EolHigh; return; } // if we prefer plans with multi-stage agg, we optimize any multi-stage agg // first to avoid later optimization of one stage agg if possible BOOL fMultiStage = CPhysicalAgg::PopConvert(m_pop)->FMultiStage(); if (fPreferMultiStageAgg && fMultiStage) { // optimize multi-stage agg first to allow avoiding one-stage agg if possible m_eol = EolHigh; } } }
void CMemberListPopLayer::_AddMemberList() { int bgTitleH = 75; int bgBorderW = 16; int headH = 40; Node *bg = getChildByTag( E_Tag_Bg ); CCAssert( bg, "bg is null" ); Size szBg = bg->getContentSize(); Size szCell( szBg.width-2*bgBorderW, headH ); Size szList( szCell.width, szBg.height-bgTitleH-bgBorderW ); CGroup *group = CUserManager::Instance().GetViewData().GetSelectGroup(); if( !group ) { CCLog( "not found select group" ); return; } vector<string> vecMember; group->Dump( vecMember ); vector<TableViewData> vecData; vector<string>::iterator it = vecMember.begin(); for( ; it != vecMember.end(); ++it ) { CGroupMember *member = group->FindMember( (*it) ); CCAssert( member, "can not believe it, member not found" ); char icon[64] = {0}; sprintf( icon, "syshead.png"); TableViewData data; data.text = member->GetName(); CalcUserHead( member->GetHead(), E_Sex_Male, data.icon, data.iconRect, data.useRect ); vecData.push_back( data ); } m_memberList = CMyTableView::create(szList, szCell, vecData, "selectbg.png" ); CCAssert( m_memberList, "CMemberListPopLayer GetTableView Failed" ); m_memberList->SetPosition( ccp(szBg.width/2, szList.height/2+bgBorderW) ); bg->addChild( m_memberList ); }
void CMilitary::remove(ARegistrar &object) { CGroup *group = dynamic_cast<CGroup*>(&object); LOG_II("CMilitary::remove " << (*group)) activeScoutGroups.erase(group->key); activeAttackGroups.erase(group->key); activeBomberGroups.erase(group->key); activeAirFighterGroups.erase(group->key); mergeGroups.erase(group->key); for (std::map<int,CGroup*>::iterator i = assemblingGroups.begin(); i != assemblingGroups.end(); ++i) { if (i->second->key == group->key) { assemblingGroups.erase(i->first); break; } } group->unreg(*this); ReusableObjectFactory<CGroup>::Release(group); }
MergeTask::MergeTask(AIClasses *_ai, std::list<CGroup*>& groups): ATask(_ai) { t = TASK_MERGE; isRetreating = false; range = 0.0f; masterGroup = NULL; std::list<CGroup*>::iterator it; for (it = groups.begin(); it != groups.end(); ++it) { CGroup *group = *it; addGroup(*group); range += group->radius(); } unitCategory cats = firstGroup()->cats; if ((cats&AIR).any() && (cats&ASSAULT).none()) { // FIXME: prefer no hardcoding range = 1000.0f; } else { range = range + groups.size() * FOOTPRINT2REAL; } }
// Правила для обособ. прил. в постпозиции\\Этим вопросом, давно и надолго забытым, \\. bool CRusFormatCaller::format_for_noun_detached_adj_postposition(CGroup& G) { size_t i, j; i = G.m_iFirstWord; const CGroup& MaxGrp = get_maximal_group(i); if (MaxGrp.m_iFirstWord != MaxGrp.m_iLastWord) i = MaxGrp.m_MainWordNo; else i = MaxGrp.m_iFirstWord; if ( !Wi.is_morph_noun() && !is_morph_pronoun(Wi)) return false; j = MaxGrp.m_iLastWord + 1; if (j == sent.size()) return false; if (!Wj.HasFlag(fl_comma)) return false; j++; if (j == sent.size()) return false; const CGroup& MaxGrpAdj = get_maximal_group(j); if (MaxGrpAdj.m_iFirstWord != MaxGrpAdj.m_iLastWord) j = MaxGrpAdj.m_MainWordNo; else j = MaxGrpAdj.m_iFirstWord; if (!is_morph_adj(Wj)) return false; if ( !(MaxGrpAdj.m_iLastWord == sent.size()-1) && !sent[MaxGrpAdj.m_iLastWord+1].HasFlag(fl_comma) ) return false; bool bGr = false; if ( GetGramTab()->GleicheGenderNumberCase(Wi.m_type_gram_code, Wi.GetGramcodes(),Wj.GetGramcodes()) ) bGr = true; if ((Wi.GetGrammems() & (1 <<rPlural)) && (Wj.GetGrammems() & (1 <<rSingular))) if ( GetGramTab()->GleicheCase(Wi.GetGramcodes(), Wj.GetGramcodes())) bGr = true; if ((Wi.GetGrammems() & (1 <<rSingular)) && (Wj.GetGrammems() & (1 <<rPlural))) if (GetGramTab()->GleicheCase(Wi.GetGramcodes(), Wj.GetGramcodes())) bGr = true; if (bGr == true) { G.m_GroupType = NOUN_DETACHED_ADJ; G.m_iFirstWord = MaxGrp.m_iFirstWord; G.m_iLastWord = MaxGrpAdj.m_iLastWord; G.m_MainGroup = MaxGrp; G.SetGrammems( Wi.GetGrammems() ); create_syn_rel(G, i, j, NOUN_DETACHED_ADJ); return true; } return false; };
//--------------------------------------------------------------------------- // @function: // CExpressionHandle::DeriveProducerStats // // @doc: // If the child (ulChildIndex) is a CTE consumer, then derive is corresponding // producer statistics. // //--------------------------------------------------------------------------- void CExpressionHandle::DeriveProducerStats ( ULONG ulChildIndex, CColRefSet *pcrsStats ) { // check to see if there are any CTE consumers in the group whose properties have // to be pushed to its corresponding CTE producer CGroupExpression *pgexpr = Pgexpr(); if (NULL != pgexpr) { CGroup *pgroupChild = (*pgexpr)[ulChildIndex]; if (pgroupChild->FHasAnyCTEConsumer()) { CGroupExpression *pgexprCTEConsumer = pgroupChild->PgexprAnyCTEConsumer(); CLogicalCTEConsumer *popConsumer = CLogicalCTEConsumer::PopConvert(pgexprCTEConsumer->Pop()); COptCtxt::PoctxtFromTLS()->Pcteinfo()->DeriveProducerStats(popConsumer, pcrsStats); } return; } // statistics are also derived on expressions representing the producer that may have // multiple CTE consumers. We should ensure that their properties are to pushed to their // corresponding CTE producer CExpression *pexpr = Pexpr(); if (NULL != pexpr) { CExpression *pexprChild = (*pexpr)[ulChildIndex]; if (COperator::EopLogicalCTEConsumer == pexprChild->Pop()->Eopid()) { CLogicalCTEConsumer *popConsumer = CLogicalCTEConsumer::PopConvert(pexprChild->Pop()); COptCtxt::PoctxtFromTLS()->Pcteinfo()->DeriveProducerStats(popConsumer, pcrsStats); } } }
//--------------------------------------------------------------------------- // @function: // CJobGroupOptimization::EevtStartOptimization // // @doc: // Start group optimization // //--------------------------------------------------------------------------- CJobGroupOptimization::EEvent CJobGroupOptimization::EevtStartOptimization ( CSchedulerContext *psc, CJob *pjOwner ) { // get a job pointer CJobGroupOptimization *pjgo = PjConvert(pjOwner); CGroup *pgroup = pjgo->m_pgroup; GPOS_ASSERT(COptimizationContext::estUnoptimized == pjgo->m_poc->Est() && "Group is already optimized under this context"); if (!pgroup->FImplemented()) { // schedule a group implementation child job CJobGroupImplementation::ScheduleJob(psc, pgroup, pjgo); return eevImplementing; } // move optimization context to optimizing state pjgo->m_poc->SetState(COptimizationContext::estOptimizing); // if this is the root, release implementation jobs if (psc->Peng()->FRoot(pgroup)) { psc->Pjf()->Truncate(EjtGroupImplementation); psc->Pjf()->Truncate(EjtGroupExpressionImplementation); } // at this point all group expressions have been added to group, // we set current job optimization level as the max group optimization level pjgo->m_eolCurrent = pgroup->EolMax(); return eevImplemented; }
bool AttackTask::onValidate() { CGroup *group = firstGroup(); if (targetAlt >= 0) { if (ai->cbc->IsUnitCloaked(targetAlt) || !group->canAttack(targetAlt)) { group->stop(); } } const UnitDef *eud = ai->cbc->GetUnitDef(target); if (eud == NULL) return false; if (!isMoving) { if (ai->cbc->IsUnitCloaked(target)) return false; return true; } if (!group->canAttack(target)) return false; // don't chase scout groups too long if they are out of base... bool scoutGroup = (group->cats&SCOUTER).any(); if (!scoutGroup && lifeTime() > 20.0f) { const unitCategory ecats = UC(eud->id); if ((ecats&SCOUTER).any() && !ai->defensematrix->isPosInBounds(pos)) return false; } float targetDistance = pos.distance2D(group->pos()); if (targetDistance > 1000.0f) return true; // too far to panic if (ai->cbc->IsUnitCloaked(target)) return false; bool isBaseThreat = ai->defensematrix->isPosInBounds(pos); // if there is no threat to our base then prevent useless attack for groups // which are not too cheap if (!isBaseThreat && (group->costMetal / group->units.size()) >= 100.0f) { float threatRange; if (scoutGroup) threatRange = 300.0f; else threatRange = 0.0f; if (group->getThreat(pos, threatRange) > group->strength) return false; } return true; }