void InterRingDisplay::drawSingleClusterOutline(InterRingCluster *node)
{
if ( fabs(node->sweep_angle - 360) > XMDV_DBL_EPSILON )
{
Vec2 p1 = mapData(radius[node->level-1], node->start_angle);
Vec2 p2 = mapData(radius[node->level], node->start_angle);
m_canvas->drawLine((float)p1.X, (float)p1.Y, (float)p2.X, (float)p2.Y);
p1 = mapData(radius[node->level-1], node->getEndAngle());
p2 = mapData(radius[node->level], node->getEndAngle());
m_canvas->drawLine((float)p1.X, (float)p1.Y, (float)p2.X, (float)p2.Y);
}
m_canvas->drawArc( center.X, center.Y, radius[node->level-1], node->start_angle, node->sweep_angle);
m_canvas->drawArc( center.X, center.Y, radius[node->level], node->start_angle, node->sweep_angle);
}
void Map::LoadMap()
{
// If file exists load, otherwise load default level
FileReader mapData(MAP_SAVE_FILE);
LoadDefaultMap();
}
void cube::pushData ()
{
/*
* pushes all data out to the specified output. (Max7221 chip in this case)
*/
mapData();
for ( int reg = 0; reg < 8; reg++ )
{
_output->put( reg + 1, _mapped_state[ reg ] );
}
}
void Map::loadMap(string fileName)
{
string line;
// Open map file
ifstream mapData(fileName.c_str());
if (mapData.is_open())
{
// Read height of the map
getline(mapData, line);
Map::height = atoi(line.c_str());
// Read width of the map
getline(mapData, line);
Map::width = atoi(line.c_str());
tileMap = new int*[Map::width];
for (int row = 0; row < Map::height; row++) {
tileMap[row] = new int[Map::width];
}
for (int row = 0; row < Map::height; row++) {
for (int col = 0; col < Map::width; col++) {
tileMap[row][col] = 0;
}
}
// Read each line of the map file and fill in the
// integers in the gameMap array.
for (int row = 0; row < Map::height; row++)
{
getline(mapData, line);
char mapTiles[1000];
strcpy_s(mapTiles, line.c_str());
for (int col = 0; col < Map::width; col++)
{
// -48 'cause char
tileMap[row][col] = mapTiles[col] - 48;
}
}
}
else
{
cerr << SDL_GetError() << endl;
}
}
void InterRingDisplay::drawSingleClusterName(InterRingCluster *node)
{
if ( node->name == NULL ) {
return;
}
if ( !( m_current_list->Contain(node) ) ) {
// If the current dimension list does not contain this node, do nothing
return;
}
m_canvas->setForeground(g_globals.colorManager->getColor(ColorManager::TEXT));
double mid_ang = node->getMidAngle();
double radi = (radius[node->level-1] + radius[node->level])/2.0;
Vec2 pos = m_canvas->mapDataToScreen( mapData(radi, mid_ang) );
m_canvas->drawString((int)pos.X, (int)pos.Y, node->name);
}
/*!
Adds \a childObject to the list of children of this map object.
The children objects are drawn in order of the QGeoMapObject::zValue()
value. Children objects having the same z value will be drawn
in the order they were added.
The map object will take ownership of \a childObject.
\since 1.1
*/
void QGeoMapGroupObject::addChildObject(QGeoMapObject *childObject)
{
if (!childObject || d_ptr->children.contains(childObject))
return;
childObject->setMapData(mapData());
childObject->d_func()->serial = d_func()->serial++;
//binary search
QList<QGeoMapObject*>::iterator i = qUpperBound(d_ptr->children.begin(),
d_ptr->children.end(),
childObject,
mapObjectLessThan);
d_ptr->children.insert(i, childObject);
connect(childObject, SIGNAL(zValueChanged(int)),
d_ptr, SLOT(childChangedZValue(int)));
emit childAdded(childObject);
}
int adjust_limits(gdouble dataMin, gdouble dataMax, gint denyMinEqualsAdjMin, gint minTMs, gint maxTMs,
gint* numTms, gdouble* tmi, gdouble* adjMin, gdouble* adjMax, gint *goodIncs, gint numGoodIncs) {
int sd = 2;
int maxPossibleGoodInc=MAPMAX(sd);
double zMin,zMax; /* zeroized limits (after unmapped above) */
double szMin,szMax; /* shifted zeroized limits */
int mszMin,mszMax; /* mapped shifted zeroized limits */
int amszMin,amszMax;/* adjusted mapped shifted zeroized limits */
double aszMin,aszMax; /* adjusted shifted zeroized limits */
double azMin,azMax; /* adjusted zeroized limits */
int falseOrigin; /* if true, we have decided on a false origin */
int mTmi; /* tick mark interval in mapped range */
int raise; /* power to which original limits must be raised
so as to map into range specified by sd */
int i; /* loop index */
int adjMaxTMs=(denyMinEqualsAdjMin?maxTMs-1:maxTMs);
/*
This is the requested maxTMs UNLESS denyMinEqualsAdjMin is true. In that case
it is possible that one of the limits will be shifted by an extra tickmark
interval after the call to adjustPosAndNegLimits. To account for this
possibility, need to decrement the maximum number of tickmarks available to
the adjstment algorithm in advance, so that the total is gauranteed to be
no more than the specified maximum.
*/
/* test to see parameters make sense */
if (dataMin>=dataMax)
return(localError("adjustLimits: bad data range"),-1);
if (minTMs<=0 || maxTMs<=0)
return(localError("adjustLimits: negative or zero tickmarks specified"),-1);
if (maxTMs==1 && denyMinEqualsAdjMin)
return(localError("adjustLimits: cannot specify 1 tickmark AND require a margin"),-1);
if (sd<1 || sd >4)
return(localError("adjustLimits: sd out of range [1,4]"),-1);
if(denyMinEqualsAdjMin && dataMin < 0 && dataMax < 0)
dataMax = 0;
/*check to see that the acceptable increments do not have more significant figures than allowed
for the limits */
for (i=0;i<numGoodIncs;i++)
{
if (goodIncs[i]>maxPossibleGoodInc)
return (localError("adjustLimits: supplied with a good increment that is too large given the number of significant digits"),-1);
if (goodIncs[i]<=0)
return (localError("adjustLimits: supplied with a good increment that is <=0"),-1);
}
/* see if either limit can be set to zero */
tryToZeroize(dataMin,dataMax,1.0/(double)maxTMs,&zMin,&zMax);
/*
Shift the origin.
Note that shifting the origin may reduce the number of significant figures.
For example (1000,1003) will be shifted to (0,3).
Therefore need to shift the data BEFORE performing the map.
Hence get (0,30) in this case.
*/
if (zMin*zMax>0) /*both of same sign and non-zero */
{
if (zMax>0)
{
falseOrigin=1; /* positive false origin */
szMax=zMax-zMin; /* remove offset */
szMin=0;
}
else {
falseOrigin=-1; /* negative false origin */
szMin=zMin-zMax; /* remove offset (zMappedMax<0 here) */
szMax=0;
}
}
else
{
/* If here, then either zMin =0, or zMax =0,
or they are both non-zero and of same sign.
In all these cases do not shift the origin */
falseOrigin=0;
szMax=zMax;
szMin=zMin;
}
/* map the data */
mapData(szMin,szMax,sd,&mszMin,&mszMax,&raise);
/* adjust limits */
if(adjustPosAndNegLimits(mszMin,mszMax,minTMs,adjMaxTMs,sd,goodIncs,numGoodIncs,numTms, &mTmi,&amszMin,&amszMax) == -1) {
*adjMin = dataMin;
*adjMax = dataMax;
*numTms = 10;
return -1;
}
/* unmap the data */
aszMin=((double)amszMin)*POWER10(-raise);
aszMax=((double)amszMax)*POWER10(-raise);
*tmi=((double)mTmi)*POWER10(-raise);
/* unshift the origin */
if (falseOrigin==1)
{
azMin=aszMin+zMin;
azMax=aszMax+zMin;
}
else if (falseOrigin==-1)
{
azMin=aszMin+zMax;
azMax=aszMax+zMax;
}
else
{
azMin=aszMin;
azMax=aszMax;
}
/* set outputs whilst performing margin adjustment */
if (denyMinEqualsAdjMin
&& falseOrigin==1
&& azMin-dataMin<*tmi) /* requested margin is absent */
{
*adjMin=azMin-*tmi; /* shift down by extra tickmark interval */
*adjMax=azMax;
(*numTms)++;
}
else if (denyMinEqualsAdjMin
&& falseOrigin==-1
&& azMax-dataMax<*tmi) /* requested margin is absent */
{
*adjMin=azMin; /* shift down by extra tickmark interval */
*adjMax=azMax+*tmi; /* shift up by extra tickmark interval */
(*numTms)++;
}
else
{
*adjMin=azMin;
*adjMax=azMax;
}
return 0;
}
void Map_v1::loadMapObjects(const char *avjFile) {
char avoName[128];
byte *dataBuf;
int16 tmp;
int32 flag;
int16 gobDataCount;
int16 objDataCount;
uint32 gobsPos;
uint32 objsPos;
strcpy(avoName, _sourceFile);
strcat(avoName, ".avo");
int32 size;
dataBuf = _vm->_dataIO->getFile(avoName, size);
if (!dataBuf) {
dataBuf = _vm->_dataIO->getFile(avjFile, size);
_loadFromAvo = false;
} else
_loadFromAvo = true;
Common::MemoryReadStream mapData(dataBuf, 4294967295U);
init();
if (_loadFromAvo) {
mapData.read(_passMap, _mapHeight * _mapWidth);
for (int y = 0; y < _mapHeight; y++)
for (int x = 0; x < _mapWidth; x++)
_itemsMap[y][x] = mapData.readSByte();
for (int i = 0; i < 40; i++) {
_wayPoints[i].x = mapData.readUint16LE();
_wayPoints[i].y = mapData.readUint16LE();
}
for (int i = 0; i < 20; i++) {
_itemPoses[i].x = mapData.readByte();
_itemPoses[i].y = mapData.readByte();
_itemPoses[i].orient = mapData.readByte();
}
}
mapData.skip(32 + 76 + 4 + 20);
for (int i = 0; i < 3; i++) {
tmp = mapData.readUint16LE();
mapData.skip(tmp * 14);
}
loadSounds(mapData);
mapData.skip(4 + 24);
gobDataCount = mapData.readUint16LE();
objDataCount = mapData.readUint16LE();
gobsPos = mapData.pos();
Common::MemoryReadStream gobsData(dataBuf + gobsPos, 4294967295U);
mapData.skip(gobDataCount * 8);
objsPos = mapData.pos();
Common::MemoryReadStream objsData(dataBuf + objsPos, 4294967295U);
mapData.skip(objDataCount * 8);
loadGoblins(mapData, gobsPos);
loadObjects(mapData, objsPos);
tmp = mapData.readUint16LE();
for (int i = 0; i < tmp; i++) {
mapData.skip(30);
flag = mapData.readSint32LE();
mapData.skip(56);
if (flag != 0)
mapData.skip(30);
}
mapData.skip(50);
loadItemToObject(mapData);
delete[] dataBuf;
}
void Map::LoadDefaultMap(void)
{
// If file exists load, otherwise load default level
FileReader mapData(MAP_DEFAULT_FILE);
assert(mapData.DoesFileExist());
// This object holds the render component that renders the map
Entity * mapRenderer = new Entity(m_context);
mapRenderer->AddNewComponentOfType<MapRenderComponent>(ComponentTypes::MapRender);
AddEntity(mapRenderer);
unsigned int xTile = 0;
unsigned int yTile = 0;
char currentTile = 0;
const unsigned int fileSize = mapData.GetFileSize();
for(unsigned int i = 0; i < fileSize; i++)
{
currentTile = mapData.ReadChar();
if(currentTile == 13)
{
continue;
}
if(currentTile == '\n')
{
xTile = 0;
yTile++;
continue;
}
bool hasEntity = false;
bool isPassable = true;
unsigned int tileIndex = 0;
unsigned int entityTileIndex = 0;
unsigned int entityZOrder = 2;
switch(currentTile)
{
case '0':
{
isPassable = true;
hasEntity = false;
tileIndex = GRASS_TILE;
}break;
case '1':
{
isPassable = false;
hasEntity = false;
tileIndex = WALL_TILE;
}break;
case '2':
{
isPassable = true;
hasEntity = true;
tileIndex = GRASS_TILE;
entityTileIndex = TREE_TILE + (rand() % 2);
}break;
case '3':
{
isPassable = true;
hasEntity = (rand()%10) > 7;
tileIndex = FIELD_TILE;
entityTileIndex = WHEAT_TILE;
entityZOrder = 3;
}break;
case '4':
{
isPassable = true;
hasEntity = true;
tileIndex = GRASS_TILE;
entityTileIndex = BRUSH_TILE;
entityZOrder = 3;
}break;
case '5':
{
isPassable = false;
hasEntity = false;
tileIndex = WATER_TILE;
}
}
MapTile* tile = new MapTile(tileIndex, isPassable);
m_Tiles.push_back(tile);
if(hasEntity)
{
Entity* entity = new Entity(m_context);
entity->SetPos(Point(static_cast<float>(xTile), static_cast<float>(yTile)));
TileRenderComponent * renderComponent = entity->AddNewComponentOfType<TileRenderComponent>(ComponentTypes::TileRender);
renderComponent->SetTileIndex(entityTileIndex);
renderComponent->SetZOrder(entityZOrder);
AddEntity(entity);
}
xTile++;
}
m_mapWidth = xTile;
m_mapHeight = yTile + 1;
m_tileSize = 32;
Entity* camera = new Entity(m_context);
camera->AddNewComponentOfType<FreeCameraComponent>(ComponentTypes::FreeCamera);
camera->SetPos(Point(0,0));
AddEntity(camera);
for(int i = 0; i < 6; i++)
{
Entity* deer = new Entity(m_context);
DeerComponent* deerComp = deer->AddNewComponentOfType<DeerComponent>(ComponentTypes::Deer);
deer->SetPos(Point(RandFloat(1,10), RandFloat(1,10)));
DeerDefinition* deerInfo = new DeerDefinition;
DeerGen::GenerateDeerInfo(deerInfo);
deerComp->SetDeerInfo(deerInfo);
unsigned int deerTile = DOE_TILE;
if(deerInfo->m_isBuck)
{
switch(deerInfo->m_age)
{
case 0: deerTile = BUCK_TILE; break;
case 1:
case 2: deerTile = BUCK_TILE + 1; break;
case 3:
case 4: deerTile = BUCK_TILE +2; break;
case 5:
default: deerTile = BUCK_TILE + 3; break;
}
}
TileRenderComponent * renderComponent = deer->AddNewComponentOfType<TileRenderComponent>(ComponentTypes::TileRender);
renderComponent->SetTileIndex(deerTile);
renderComponent->SetZOrder(4);
AddEntity(deer);
}
}
void Map_v2::loadMapObjects(char *avjFile) {
int i;
int j;
int k;
uint8 wayPointsCount;
int16 var;
int16 id;
int16 mapHeight;
int16 mapWidth;
int16 tmp;
int16 numData;
int16 statesCount;
int16 state;
char *variables;
char *extData;
uint32 dataPos1;
uint32 dataPos2;
int8 statesMask[102];
Mult::Mult_GobState *statesPtr;
var = _vm->_parse->parseVarIndex();
variables = _vm->_global->_inter_variables + var;
id = _vm->_inter->load16();
if (id == -1) {
_passMap = (int8 *)(_vm->_global->_inter_variables + var);
return;
}
extData = _vm->_game->loadExtData(id, 0, 0);
Common::MemoryReadStream mapData((byte *) extData, 4294967295U);
if (mapData.readByte() == 3) {
_screenWidth = 640;
_passWidth = 65;
} else {
_screenWidth = 320;
_passWidth = 40;
}
_wayPointsCount = mapData.readByte();
_tilesWidth = mapData.readSint16LE();
_tilesHeight = mapData.readSint16LE();
_bigTiles = !(_tilesHeight & 0xFF00);
_tilesHeight &= 0xFF;
_mapWidth = _screenWidth / _tilesWidth;
_mapHeight = 200 / _tilesHeight;
dataPos2 = mapData.pos();
mapData.seek(_mapWidth * _mapHeight, SEEK_CUR);
if (*extData == 1)
wayPointsCount = _wayPointsCount = 40;
else
wayPointsCount = _wayPointsCount == 0 ? 1 : _wayPointsCount;
_wayPoints = new Point[wayPointsCount];
for (i = 0; i < _wayPointsCount; i++) {
_wayPoints[i].x = mapData.readSByte();
_wayPoints[i].y = mapData.readSByte();
_wayPoints[i].field_2 = mapData.readSByte();
}
// In the original asm, this writes byte-wise into the variables-array
dataPos1 = mapData.pos();
if (variables != _vm->_global->_inter_variables) {
_passMap = (int8 *) variables;
mapHeight = 200 / _tilesHeight;
mapWidth = _screenWidth / _tilesWidth;
for (i = 0; i < mapHeight; i++) {
mapData.seek(dataPos2 + (mapWidth * i));
for (j = 0; j < mapWidth; j++) {
setPass(j, i, mapData.readSByte());
}
}
}
mapData.seek(dataPos1);
tmp = mapData.readSint16LE();
mapData.seek(tmp * 14, SEEK_CUR);
tmp = mapData.readSint16LE();
mapData.seek(tmp * 14 + 28, SEEK_CUR);
tmp = mapData.readSint16LE();
mapData.seek(tmp * 14, SEEK_CUR);
_vm->_goblin->_gobsCount = tmp;
for (i = 0; i < _vm->_goblin->_gobsCount; i++) {
memset(statesMask, -1, 101);
_vm->_mult->_objects[i].goblinStates = new Mult::Mult_GobState*[101];
memset(_vm->_mult->_objects[i].goblinStates, 0, 101 * sizeof(Mult::Mult_GobState *));
mapData.read(statesMask, 100);
dataPos1 = mapData.pos();
statesCount = 0;
for (j = 0; j < 100; j++) {
if (statesMask[j] != -1) {
statesCount++;
mapData.seek(4, SEEK_CUR);
numData = mapData.readByte();
statesCount += numData;
mapData.seek(numData * 9, SEEK_CUR);
}
}
statesPtr = new Mult::Mult_GobState[statesCount];
_vm->_mult->_objects[i].goblinStates[0] = statesPtr;
mapData.seek(dataPos1);
for (j = 0; j < 100; j++) {
state = statesMask[j];
if (state != -1) {
_vm->_mult->_objects[i].goblinStates[state] = statesPtr++;
_vm->_mult->_objects[i].goblinStates[state][0].animation = mapData.readSint16LE();
_vm->_mult->_objects[i].goblinStates[state][0].layer = mapData.readSint16LE();
numData = mapData.readByte();
_vm->_mult->_objects[i].goblinStates[state][0].dataCount = numData;
for (k = 1; k <= numData; k++) {
mapData.seek(1, SEEK_CUR);
_vm->_mult->_objects[i].goblinStates[state][k].sndItem = mapData.readSByte();
mapData.seek(1, SEEK_CUR);
_vm->_mult->_objects[i].goblinStates[state][k].sndFrame = mapData.readByte();
mapData.seek(1, SEEK_CUR);
_vm->_mult->_objects[i].goblinStates[state][k].freq = mapData.readSint16LE();
_vm->_mult->_objects[i].goblinStates[state][k].repCount = mapData.readSByte();
_vm->_mult->_objects[i].goblinStates[state][k].speaker = mapData.readByte();
statesPtr++;
}
}
}
}
_vm->_goblin->_soundSlotsCount = _vm->_inter->load16();
for (i = 0; i < _vm->_goblin->_soundSlotsCount; i++)
_vm->_goblin->_soundSlots[i] = _vm->_inter->loadSound(1);
}
