bool TMap::serialize( QDataStream & ofs )
{
version = CURRENT_MAP_VERSION;
ofs << version;
ofs << envColors;
ofs << mpRoomDB->getAreaNamesMap();
ofs << customEnvColors;
ofs << mpRoomDB->hashTable;
ofs << mpRoomDB->getAreaMap().size();
// serialize area table
QMapIterator<int, TArea *> itAreaList(mpRoomDB->getAreaMap());
while( itAreaList.hasNext() )
{
itAreaList.next();
int areaId = itAreaList.key();
TArea * pA = itAreaList.value();
ofs << areaId;
ofs << pA->rooms;
ofs << pA->ebenen;
ofs << pA->exits;
ofs << pA->gridMode;
ofs << pA->max_x;
ofs << pA->max_y;
ofs << pA->max_z;
ofs << pA->min_x;
ofs << pA->min_y;
ofs << pA->min_z;
ofs << pA->span;
ofs << pA->xmaxEbene;
ofs << pA->ymaxEbene;
ofs << pA->zmaxEbene;
ofs << pA->xminEbene;
ofs << pA->yminEbene;
ofs << pA->zminEbene;
ofs << pA->pos;
ofs << pA->isZone;
ofs << pA->zoneAreaRef;
}
if (mRoomId)
ofs << mRoomId;
else{
mRoomId = 0;
ofs << mRoomId;
}
ofs << mapLabels.size(); //anzahl der areas
QMapIterator<int, QMap<int, TMapLabel> > itL1(mapLabels);
while( itL1.hasNext() )
{
itL1.next();
int i = itL1.key();
ofs << itL1.value().size();//anzahl der labels pro area
ofs << itL1.key(); //area id
QMapIterator<int, TMapLabel> itL2(mapLabels[i]);
while( itL2.hasNext() )
{
itL2.next();
// N/U: int ii = itL2.key();
ofs << itL2.key();//label ID
TMapLabel label = itL2.value();
ofs << label.pos;
ofs << label.pointer;
ofs << label.size;
ofs << label.text;
ofs << label.fgColor;
ofs << label.bgColor;
ofs << label.pix;
ofs << label.noScaling;
ofs << label.showOnTop;
}
}
QMapIterator<int, TRoom *> it( mpRoomDB->getRoomMap() );
while( it.hasNext() )
{
it.next();
// N/U: int i = it.key();
TRoom * pR = it.value();
ofs << pR->getId();
ofs << pR->getAreaId();
ofs << pR->x;
ofs << pR->y;
ofs << pR->z;
ofs << pR->getNorth();
ofs << pR->getNortheast();
ofs << pR->getEast();
ofs << pR->getSoutheast();
ofs << pR->getSouth();
ofs << pR->getSouthwest();
ofs << pR->getWest();
ofs << pR->getNorthwest();
ofs << pR->getUp();
ofs << pR->getDown();
ofs << pR->getIn();
ofs << pR->getOut();
ofs << pR->environment;
ofs << pR->getWeight();
// ofs << rooms[i]->xRot;
// ofs << rooms[i]->yRot;
// ofs << rooms[i]->zRot;
// ofs << rooms[i]->zoom;
ofs << pR->name;
ofs << pR->isLocked;
ofs << pR->getOtherMap();
ofs << pR->c;
ofs << pR->userData;
ofs << pR->customLines;
ofs << pR->customLinesArrow;
ofs << pR->customLinesColor;
ofs << pR->customLinesStyle;
ofs << pR->exitLocks;
ofs << pR->exitStubs;
ofs << pR->getExitWeights();
ofs << pR->doors;
}
return true;
}
void TMap::initGraph()
{
QTime _time; _time.start();
locations.clear();
roomidToIndex.clear();
g.clear();
g = mygraph_t();
weightmap = get(edge_weight, g);
QList<TRoom*> roomList = mpRoomDB->getRoomPtrList();
int roomCount=0;
int edgeCount=0;
for( int _k=0; _k<roomList.size(); _k++ )
{
TRoom * pR = roomList[_k];
int i = pR->getId();
if( pR->isLocked || i < 1 )
{
continue;
}
roomCount++;
// int roomExits = edgeCount;
location l;
l.x = pR->x;
l.y = pR->y;
l.z = pR->z;
l.id = pR->getId();
l.area = pR->getAreaId();
locations.push_back( l );
}
for(unsigned int i=0;i<locations.size();i++){
roomidToIndex[locations[i].id] = i;
indexToRoomid[i] = locations[i].id;
}
for( int _k=0; _k<roomList.size(); _k++ ){
TRoom * pR = roomList[_k];
if( pR->isLocked || !roomidToIndex.contains(pR->getId()) )
{
continue;
}
int roomIndex = roomidToIndex[pR->getId()];
TRoom * pN = mpRoomDB->getRoom( pR->getNorth() );
TRoom * pNW = mpRoomDB->getRoom( pR->getNorthwest() );
TRoom * pNE = mpRoomDB->getRoom( pR->getNortheast() );
TRoom * pS = mpRoomDB->getRoom( pR->getSouth() );
TRoom * pSW = mpRoomDB->getRoom( pR->getSouthwest() );
TRoom * pSE = mpRoomDB->getRoom( pR->getSoutheast() );
TRoom * pW = mpRoomDB->getRoom( pR->getWest() );
TRoom * pE = mpRoomDB->getRoom( pR->getEast() );
TRoom * pUP = mpRoomDB->getRoom( pR->getUp() );
TRoom * pDOWN = mpRoomDB->getRoom( pR->getDown() );
TRoom * pIN = mpRoomDB->getRoom( pR->getIn() );
TRoom * pOUT = mpRoomDB->getRoom( pR->getOut() );
QMap<QString, int> exitWeights = pR->getExitWeights();
if( pN && !pN->isLocked )
{
if( !pR->hasExitLock( DIR_NORTH ) )
{
//edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getNorth()],
g );
if( exitWeights.contains("n"))
weightmap[e] = pR->getExitWeight("n");
else
weightmap[e] = pN->getWeight();
}
}
if( pS && !pS->isLocked )
{
if( !pR->hasExitLock( DIR_SOUTH ) )
{
//edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getSouth()],
g );
if( exitWeights.contains("s"))
weightmap[e] = pR->getExitWeight("s");
else
weightmap[e] = pS->getWeight();
}
}
if( pNE && !pNE->isLocked )
{
if( !pR->hasExitLock( DIR_NORTHEAST ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getNortheast()],
g );
if( exitWeights.contains("ne"))
weightmap[e] = pR->getExitWeight("ne");
else
weightmap[e] = pNE->getWeight();
}
}
if( pE && !pE->isLocked )
{
if( !pR->hasExitLock( DIR_EAST ) )
{
//edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getEast()],
g );
if( exitWeights.contains("e"))
weightmap[e] = pR->getExitWeight("e");
else
weightmap[e] = pE->getWeight();
}
}
if( pW && !pW->isLocked )
{
if( !pR->hasExitLock( DIR_WEST ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getWest()],
g );
if( exitWeights.contains("w"))
weightmap[e] = pR->getExitWeight("w");
else
weightmap[e] = pW->getWeight();
}
}
if( pSW && !pSW->isLocked )
{
if( !pR->hasExitLock( DIR_SOUTHWEST ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getSouthwest()],
g );
if( exitWeights.contains("sw"))
weightmap[e] = pR->getExitWeight("sw");
else
weightmap[e] = pSW->getWeight();
}
}
if( pSE && !pSE->isLocked )
{
if( !pR->hasExitLock( DIR_SOUTHEAST ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getSoutheast()],
g );
if( exitWeights.contains("se"))
weightmap[e] = pR->getExitWeight("se");
else
weightmap[e] = pSE->getWeight();
}
}
if( pNW && !pNW->isLocked )
{
if( !pR->hasExitLock( DIR_NORTHWEST ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getNorthwest()],
g );
if( exitWeights.contains("nw"))
weightmap[e] = pR->getExitWeight("nw");
else
weightmap[e] = pNW->getWeight();
}
}
if( pUP && !pUP->isLocked )
{
if( !pR->hasExitLock( DIR_UP ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getUp()],
g );
if( exitWeights.contains("up"))
weightmap[e] = pR->getExitWeight("up");
else
weightmap[e] = pUP->getWeight();
}
}
if( pDOWN && !pDOWN->isLocked )
{
if( !pR->hasExitLock( DIR_DOWN ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getDown()],
g );
if( exitWeights.contains("down"))
weightmap[e] = pR->getExitWeight("down");
else
weightmap[e] = pDOWN->getWeight();
}
}
if( pIN && !pIN->isLocked )
{
if( !pR->hasExitLock( DIR_IN ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getIn()],
g );
if( exitWeights.contains("in"))
weightmap[e] = pR->getExitWeight("in");
else
weightmap[e] = pIN->getWeight();
}
}
if( pOUT && !pOUT->isLocked )
{
if( !pR->hasExitLock( DIR_OUT ) )
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pR->getOut()],
g );
if( exitWeights.contains("out"))
weightmap[e] = pR->getExitWeight("out");
else
weightmap[e] = pOUT->getWeight();
}
}
if( pR->getOtherMap().size() > 0 )
{
QMapIterator<int, QString> it( pR->getOtherMap() );
while( it.hasNext() )
{
it.next();
int _id = it.key();
QString _cmd = it.value();
if( _cmd.size()>0 ) _cmd.remove(0,1);//strip special exit lock information
TRoom * pSpecial = mpRoomDB->getRoom( _id );
if( !pSpecial || pR->hasSpecialExitLock( _id, _cmd ) || pSpecial->isLocked)
continue;
else
{
// edgeCount++;
edge_descriptor e;
bool inserted;
tie(e, inserted) = add_edge( roomIndex,
roomidToIndex[pSpecial->getId()],
g );
if( exitWeights.contains(_cmd))
{
weightmap[e] = pR->getExitWeight(_cmd);
}
else
{
weightmap[e] = pSpecial->getWeight();
}
}
}
}
// if( roomExits == edgeCount ) locations.pop_back();
}
mMapGraphNeedsUpdate = false;
qDebug("TMap::initGraph(): nodes/room Counts: %i / %i edges: %i run time: %imSec.",
locations.size(),
roomCount,
edgeCount,
_time.elapsed());
}
