void CDynGameData::RemoveLocalPlayer( CPlayer *aPlayer )
{
CheckPlayersLiving();
// Things to do when player dies
// 1. Add player to dead players' list (needed so that we know how many players there was)
// 2. Remove from local players (so that screen disappears)
// 3. Fix mouse control (is it needed nowadays?)
// 4. something else?
if (iLocalPlayer.size()>1)
{
// Remove player from active players
MoveToDeads( aPlayer );
CGameStatisticsData::TPlayerStats& stat = Statistics()->PlayerStats( aPlayer );
stat.iLevelOfDeath = CurrentLevel();
}
}
void IlukGraph<LocalOrdinal,GlobalOrdinal,Node>::constructFilledGraph() {
size_t NumIn, NumL, NumU;
bool DiagFound;
constructOverlapGraph();
L_Graph_ = Teuchos::rcp( new TpetraCrsGraphType(OverlapGraph_->getRowMap(), OverlapGraph_->getRowMap(), 0));
U_Graph_ = Teuchos::rcp( new TpetraCrsGraphType(OverlapGraph_->getRowMap(), OverlapGraph_->getRowMap(), 0));
// Get Maximum Row length
int MaxNumIndices = OverlapGraph_->getNodeMaxNumRowEntries();
Teuchos::Array<LocalOrdinal> L(MaxNumIndices);
Teuchos::Array<LocalOrdinal> U(MaxNumIndices);
// First we copy the user's graph into L and U, regardless of fill level
int NumMyRows = OverlapGraph_->getRowMap()->getNodeNumElements();
NumMyDiagonals_ = 0;
for (int i=0; i< NumMyRows; i++) {
Teuchos::ArrayView<const LocalOrdinal> my_indices;
OverlapGraph_->getLocalRowView(i,my_indices);
// Split into L and U (we don't assume that indices are ordered).
NumL = 0;
NumU = 0;
DiagFound = false;
NumIn = my_indices.size();
for (size_t j=0; j< NumIn; j++) {
LocalOrdinal k = my_indices[j];
if (k<NumMyRows) { // Ignore column elements that are not in the square matrix
if (k==i) DiagFound = true;
else if (k < i) {
L[NumL] = k;
NumL++;
}
else {
U[NumU] = k;
NumU++;
}
}
}
// Check in things for this row of L and U
if (DiagFound) ++NumMyDiagonals_;
if (NumL) {
Teuchos::ArrayView<LocalOrdinal> Lview(&L[0], NumL);
L_Graph_->insertLocalIndices(i, Lview );
}
if (NumU) {
Teuchos::ArrayView<LocalOrdinal> Uview(&U[0], NumU);
U_Graph_->insertLocalIndices(i, Uview );
}
}
if (LevelFill_ > 0) {
// Complete Fill steps
Teuchos::RCP<const TpetraMapType> L_DomainMap = OverlapGraph_->getRowMap();
Teuchos::RCP<const TpetraMapType> L_RangeMap = Graph_->getRangeMap();
Teuchos::RCP<const TpetraMapType> U_DomainMap = Graph_->getDomainMap();
Teuchos::RCP<const TpetraMapType> U_RangeMap = OverlapGraph_->getRowMap();
Teuchos::RCP<Teuchos::ParameterList> params = Teuchos::rcp(new Teuchos::ParameterList());
params->set("Optimize Storage",false);
L_Graph_->fillComplete(L_DomainMap, L_RangeMap, params);
U_Graph_->fillComplete(U_DomainMap, U_RangeMap, params);
L_Graph_->resumeFill();
U_Graph_->resumeFill();
// At this point L_Graph and U_Graph are filled with the pattern of input graph,
// sorted and have redundant indices (if any) removed. Indices are zero based.
// LevelFill is greater than zero, so continue...
int MaxRC = NumMyRows;
std::vector<std::vector<int> > Levels(MaxRC);
std::vector<int> LinkList(MaxRC);
std::vector<int> CurrentLevel(MaxRC);
Teuchos::Array<LocalOrdinal> CurrentRow(MaxRC+1);
std::vector<int> LevelsRowU(MaxRC);
for (int i=0; i<NumMyRows; i++)
{
int First, Next;
// copy column indices of row into workspace and sort them
size_t LenL = L_Graph_->getNumEntriesInLocalRow(i);
size_t LenU = U_Graph_->getNumEntriesInLocalRow(i);
size_t Len = LenL + LenU + 1;
CurrentRow.resize(Len);
L_Graph_->getLocalRowCopy(i, CurrentRow(), LenL); // Get L Indices
CurrentRow[LenL] = i; // Put in Diagonal
if (LenU > 0) {
Teuchos::ArrayView<LocalOrdinal> URowView(&CurrentRow[LenL+1], LenU);
// Get U Indices
U_Graph_->getLocalRowCopy(i, URowView, LenU);
}
// Construct linked list for current row
for (size_t j=0; j<Len-1; j++) {
LinkList[CurrentRow[j]] = CurrentRow[j+1];
CurrentLevel[CurrentRow[j]] = 0;
}
LinkList[CurrentRow[Len-1]] = NumMyRows;
CurrentLevel[CurrentRow[Len-1]] = 0;
// Merge List with rows in U
First = CurrentRow[0];
Next = First;
while (Next < i)
{
int PrevInList = Next;
int NextInList = LinkList[Next];
int RowU = Next;
// Get Indices for this row of U
Teuchos::ArrayView<const LocalOrdinal> IndicesU;
U_Graph_->getLocalRowView(RowU,IndicesU);
int LengthRowU = IndicesU.size();
int ii;
// Scan RowU
for (ii=0; ii<LengthRowU; /*nop*/)
{
int CurInList = IndicesU[ii];
if (CurInList < NextInList)
{
// new fill-in
int NewLevel = CurrentLevel[RowU] + Levels[RowU][ii+1] + 1;
if (NewLevel <= LevelFill_)
{
LinkList[PrevInList] = CurInList;
LinkList[CurInList] = NextInList;
PrevInList = CurInList;
CurrentLevel[CurInList] = NewLevel;
}
ii++;
}
else if (CurInList == NextInList)
{
PrevInList = NextInList;
NextInList = LinkList[PrevInList];
int NewLevel = CurrentLevel[RowU] + Levels[RowU][ii+1] + 1;
CurrentLevel[CurInList] = std::min(CurrentLevel[CurInList], NewLevel);
ii++;
}
else // (CurInList > NextInList)
{
PrevInList = NextInList;
NextInList = LinkList[PrevInList];
}
}
Next = LinkList[Next];
}
// Put pattern into L and U
CurrentRow.resize(0);
Next = First;
// Lower
while (Next < i) {
CurrentRow.push_back(Next);
Next = LinkList[Next];
}
L_Graph_->removeLocalIndices(i); // Delete current set of Indices
if (CurrentRow.size() > 0) {
L_Graph_->insertLocalIndices(i, CurrentRow());
}
// Diagonal
TEUCHOS_TEST_FOR_EXCEPTION(Next != i, std::runtime_error,
"Ifpack2::IlukGraph::constructFilledGraph: FATAL: U has zero diagonal")
LevelsRowU[0] = CurrentLevel[Next];
Next = LinkList[Next];
// Upper
CurrentRow.resize(0);
LenU = 0;
while (Next < NumMyRows) {
LevelsRowU[LenU+1] = CurrentLevel[Next];
CurrentRow.push_back(Next);
++LenU;
Next = LinkList[Next];
}
U_Graph_->removeLocalIndices(i); // Delete current set of Indices
if (LenU > 0) {
U_Graph_->insertLocalIndices(i, CurrentRow());
}
// Allocate and fill Level info for this row
Levels[i] = std::vector<int>(LenU+1);
for (size_t jj=0; jj<LenU+1; jj++) {
Levels[i][jj] = LevelsRowU[jj];
}
}
}
// Complete Fill steps
Teuchos::RCP<const TpetraMapType> L_DomainMap = OverlapGraph_->getRowMap();
Teuchos::RCP<const TpetraMapType> L_RangeMap = Graph_->getRangeMap();
Teuchos::RCP<const TpetraMapType> U_DomainMap = Graph_->getDomainMap();
Teuchos::RCP<const TpetraMapType> U_RangeMap = OverlapGraph_->getRowMap();
L_Graph_->fillComplete(L_DomainMap, L_RangeMap);//DoOptimizeStorage is default here...
U_Graph_->fillComplete(U_DomainMap, U_RangeMap);//DoOptimizeStorage is default here...
Teuchos::reduceAll<int,size_t>(*(L_DomainMap->getComm()), Teuchos::REDUCE_SUM, 1, &NumMyDiagonals_, &NumGlobalDiagonals_);
}
void LevelGame::LoadNextLevel(Scene *scene) {
CurrentLevel()->Load(scene);
}
