MapTile* Map::createMapTileWithoutBody (const SpriteDefPtr& spriteDef, gridCoord gridX, gridCoord gridY, EntityAngle angle)
{
MapTile* mapTile;
const SpriteType& type = spriteDef->type;
if (SpriteTypes::isCave(type)) {
mapTile = new CaveMapTile(*this, spriteDef->id, gridX, gridY);
} else if (SpriteTypes::isBackground(type)) {
mapTile = new MapTile(*this, spriteDef->id, gridX, gridY, EntityTypes::DECORATION);
} else if (SpriteTypes::isWindow(type)) {
mapTile = new WindowTile(*this, spriteDef->id, gridX, gridY);
} else if (SpriteTypes::isLava(type)) {
mapTile = new MapTile(*this, spriteDef->id, gridX, gridY, EntityTypes::LAVA);
} else if (SpriteTypes::isPackageTarget(type)) {
mapTile = new PackageTarget(*this, spriteDef->id, gridX, gridY);
} else if (SpriteTypes::isGeyser(type)) {
mapTile = new Geyser(*this, spriteDef->id, gridX, gridY, _initialGeyserDelay);
} else if (SpriteTypes::isAnyGround(type) || SpriteTypes::isBridge(type)) {
mapTile = new MapTile(*this, spriteDef->id, gridX, gridY, EntityTypes::GROUND);
} else if (SpriteTypes::isSolid(type)) {
mapTile = new MapTile(*this, spriteDef->id, gridX, gridY, EntityTypes::SOLID);
} else {
mapTile = new MapTile(*this, spriteDef->id, gridX, gridY, EntityTypes::DECORATION);
}
mapTile->setGridDimensions(spriteDef->width, spriteDef->height, angle);
return mapTile;
}
void GeoJson::extractPoint(const rapidjson::Value& _in, Point& _out, const MapTile& _tile) {
glm::dvec2 tmp = _tile.getProjection()->LonLatToMeters(glm::dvec2(_in[0].GetDouble(), _in[1].GetDouble()));
_out.x = (tmp.x - _tile.getOrigin().x) * _tile.getInverseScale();
_out.y = (tmp.y - _tile.getOrigin().y) * _tile.getInverseScale();
}
void Map::setZoom(int z)
{
MapTile *pTile;
int rowNr;
int rows;
int colNr;
int cols;
rows = m_tileMatrix.size();
for(rowNr=0; rowNr<rows; rowNr++)
{
cols = m_tileMatrix[rowNr].size();
for(colNr=0; colNr<cols; colNr++)
{
pTile = m_tileMatrix[rowNr][colNr];
if(pTile != NULL)
{
pTile->setZoom(z);
}
}
}
m_zoom = z;
}
void DebugTextStyle::addData(TileData& _data, MapTile& _tile, const MapProjection& _mapProjection) {
if (Tangram::getDebugFlag(Tangram::DebugFlags::TILE_INFOS)) {
onBeginBuildTile(_tile);
std::shared_ptr<VboMesh> mesh(new Mesh(m_vertexLayout, m_drawMode));
auto ftContext = m_labels->getFontContext();
auto textBuffer = _tile.getTextBuffer(*this);
ftContext->setFont(m_fontName, m_fontSize * m_pixelScale);
if (m_sdf) {
float blurSpread = 2.5;
ftContext->setSignedDistanceField(blurSpread);
}
std::string tileID = std::to_string(_tile.getID().x) + "/" + std::to_string(_tile.getID().y) + "/" + std::to_string(_tile.getID().z);
m_labels->addLabel(_tile, m_name, { glm::vec2(0), glm::vec2(0) }, tileID, Label::Type::DEBUG);
onEndBuildTile(_tile, mesh);
mesh->compileVertexBuffer();
_tile.addGeometry(*this, mesh);
}
}
std::shared_ptr<TileData> GeoJsonSource::parse(const MapTile& _tile, std::stringstream& _in) {
std::shared_ptr<TileData> tileData = std::make_shared<TileData>();
// parse written data into a JSON object
rapidjson::Document doc;
doc.Parse(_in.str().c_str());
if (doc.HasParseError()) {
logMsg("Json parsing failed on tile [%d, %d, %d]\n", _tile.getID().z, _tile.getID().x, _tile.getID().y);
return tileData;
}
// transform JSON data into a TileData using GeoJson functions
for (auto layer = doc.MemberBegin(); layer != doc.MemberEnd(); ++layer) {
tileData->layers.emplace_back(std::string(layer->name.GetString()));
GeoJson::extractLayer(layer->value, tileData->layers.back(), _tile);
}
// Discard original JSON object and return TileData
return tileData;
}
bool MapTileLayer::addTile(const MapTileInfo& info, const Coordinate& position, const Coordinate& size, bool async)
{
if(!info.blank)
{
const MapTileInfo& blank = MapViewLayer::Context.Loader->getBlankTile();
MapTile* tile = MapTile::create(blank, size);
tile->setPosition(position);
// push blank tiles all way to the back
addChild(tile, -100);
}
MapTile* tile = nullptr;
if(async)
{
tile = MapTile::createAsync(info, size);
}
else
{
tile = MapTile::create(info, size);
}
tile->setPosition(position);
// draw tiles with lower LOD first
addChild(tile, -info.lod);
return !tile->isLoaded();
}
bool Engine::validWalkableTile(MapChunk *tmap, int x, int y)
{
if(tmap == NULL) return false;
sf::Vector2i tpos(x,y);
//check that tile is within map dimensions
sf::Vector2i mapdim = tmap->getDimensions();
if(x < 0 || y < 0 || x >= mapdim.x || y >= mapdim.y) return false;
//check that tile is walkable
MapTile *ttile = getMapTile( tmap->getTile(x,y) );
if(!ttile->isWalkable()) return false;
//check that there are no actors there
std::vector<Monster*> *actors = tmap->getMapMonsters();
for(int i = 0; i < int(actors->size()); i++)
{
if((*actors)[i]->getPosition() == tpos) return false;
}
//check if player is there
if( m_Player->getPosition() == tpos) return false;
return true;
}
void Engine::drawMap()
{
for(int i = 0; i < m_CurrentMap->getDimensions().y; i++)
{
for(int n = 0; n < m_CurrentMap->getDimensions().x; n++)
{
MapTile *ttile = getMapTile( m_CurrentMap->getTile(n, i));
if(posInViewport(n, i))
{
if( inFOV(m_Player->getPosition().x, m_Player->getPosition().y, n, i) )
{
drawTileInViewport(n, i, ttile->getTileID(), ttile->getFGColor(), ttile->getBGColor());
if(!m_CurrentMap->tileExplored(n,i)) m_CurrentMap->setExplored(n, i, true);
}
else
if( m_CurrentMap->tileExplored(n, i) ) drawTileInViewport(n, i, ttile->getTileID(), SFC_WHITE, SFC_BLACK);
}
}
}
}
// -----------------------------------------------------------------
// Name : changeTerrainType
// -----------------------------------------------------------------
void Map::changeTerrainType(CoordsMap pos, u8 uType, Server * pServer)
{
MapTile * pTile = getTileAt(pos);
pTile->m_uTerrainType = uType;
if (pServer != NULL)
{
NetworkData msg(NETWORKMSG_CHANGE_TERRAIN);
msg.addLong(pos.x);
msg.addLong(pos.y);
msg.addLong(uType);
pServer->sendMessageToAllClients(&msg);
}
else
{
pTile->resetTexture(pTile->getDisplay());
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
int x = pos.x + i;
int y = pos.y + j;
if (x < 0 || y < 0 || x >= m_iWidth || y >= m_iHeight)
continue;
setTileMask(x, y);
}
}
}
}
void Style::addData(TileData& _data, MapTile& _tile, const MapProjection& _mapProjection) {
onBeginBuildTile(_tile);
std::shared_ptr<VboMesh> mesh(newMesh());
for (auto& layer : _data.layers) {
// Skip any layers that this style doesn't have a rule for
auto it = m_layers.begin();
while (it != m_layers.end() && it->first != layer.name) { ++it; }
if (it == m_layers.end()) { continue; }
// Loop over all features
for (auto& feature : layer.features) {
/*
* TODO: do filter evaluation for each feature for sublayer!
* construct a unique ID for a the set of filters matched
* use this ID pass to the style's parseStyleParams method to construct styleParam cache
* NOTE: for the time being use layerName as ID for cache
*/
feature.props.numericProps["zoom"] = _tile.getID().z;
switch (feature.geometryType) {
case GeometryType::POINTS:
// Build points
for (auto& point : feature.points) {
buildPoint(point, parseStyleParams(it->first, it->second), feature.props, *mesh);
}
break;
case GeometryType::LINES:
// Build lines
for (auto& line : feature.lines) {
buildLine(line, parseStyleParams(it->first, it->second), feature.props, *mesh);
}
break;
case GeometryType::POLYGONS:
// Build polygons
for (auto& polygon : feature.polygons) {
buildPolygon(polygon, parseStyleParams(it->first, it->second), feature.props, *mesh);
}
break;
default:
break;
}
}
}
onEndBuildTile(_tile, mesh);
if (mesh->numVertices() == 0) {
mesh.reset();
} else {
mesh->compileVertexBuffer();
_tile.addGeometry(*this, mesh);
}
}
bool AppStateGameMode::render(sf::RenderTarget& target, int frame)
{
// Set focus for areas.
the_message_log.set_focus(pImpl->current_input_state == GameInputState::MessageLog);
pImpl->status_area->set_focus(pImpl->current_input_state == GameInputState::Map);
ThingRef player = TM.get_player();
ThingRef location = player->get_location();
if (location == TM.get_mu())
{
throw std::exception("Uh oh, the player's location appears to have been deleted!");
}
/// @todo We need a way to determine if the player is directly on a map,
/// and render either the map, or a container interior.
/// Should probably use an overridden "render_surroundings" method
/// for Things.
if (!player->is_inside_another_thing())
{
MapTile* tile = player->get_maptile();
if (tile != nullptr)
{
Map& game_map = MF.get(tile->get_map_id());
sf::Vector2i tile_coords = tile->get_coords();
sf::Vector2f player_pixel_coords = MapTile::get_pixel_coords(tile_coords);
sf::Vector2f cursor_pixel_coords = MapTile::get_pixel_coords(pImpl->cursor_coords);
// Update thing vertex array.
game_map.update_thing_vertices(player, frame);
if (pImpl->current_input_state == GameInputState::CursorLook)
{
game_map.set_view(target, cursor_pixel_coords, pImpl->map_zoom_level);
game_map.draw_to(target);
auto& cursor_tile = game_map.get_tile(pImpl->cursor_coords);
cursor_tile.draw_highlight(target,
cursor_pixel_coords,
Settings.get<sf::Color>("cursor_border_color"),
Settings.get<sf::Color>("cursor_bg_color"),
frame);
}
else
{
game_map.set_view(target, player_pixel_coords, pImpl->map_zoom_level);
game_map.draw_to(target);
}
}
}
the_message_log.render(target, frame);
pImpl->status_area->render(target, frame);
pImpl->inventory_area->render(target, frame);
return true;
}
bool Map::load (const std::string& name)
{
ScopedPtr<IMapContext> ctx(getMapContext(name));
resetCurrentMap();
if (name.empty()) {
info(LOG_MAP, "no map name given");
return false;
}
info(LOG_MAP, "load map " + name);
if (!ctx->load(false)) {
error(LOG_MAP, "failed to load the map " + name);
return false;
}
ctx->save();
_settings = ctx->getSettings();
_startPositions = ctx->getStartPositions();
_name = ctx->getName();
_title = ctx->getTitle();
_width = getSetting(msn::WIDTH, "-1").toInt();
_height = getSetting(msn::HEIGHT, "-1").toInt();
_solution = getSolution();
const std::string solutionSteps = string::toString(_solution.length());
_settings.insert(std::make_pair("best", solutionSteps));
info(LOG_MAP, "Solution has " + solutionSteps + " steps");
if (_width <= 0 || _height <= 0) {
error(LOG_MAP, "invalid map dimensions given");
return false;
}
const std::vector<MapTileDefinition>& mapTileList = ctx->getMapTileDefinitions();
for (std::vector<MapTileDefinition>::const_iterator i = mapTileList.begin(); i != mapTileList.end(); ++i) {
const SpriteType& t = i->spriteDef->type;
info(LOG_MAP, "sprite type: " + t.name + ", " + i->spriteDef->id);
MapTile *mapTile = new MapTile(*this, i->x, i->y, getEntityTypeForSpriteType(t));
mapTile->setSpriteID(i->spriteDef->id);
mapTile->setAngle(randBetweenf(-0.1, 0.1f));
loadEntity(mapTile);
}
info(LOG_MAP, String::format("map loading done with %i tiles", mapTileList.size()));
ctx->onMapLoaded();
_frontend->onMapLoaded();
const LoadMapMessage msg(_name, _title);
_serviceProvider->getNetwork().sendToAllClients(msg);
_mapRunning = true;
return true;
}
void WarpTile::reopen() {
holePixmap.setVisible(true);
holeOpen = true;
if(position().x() < MAPW/2) {
MapTile *mt = playfield->tileAt(position() + QPoint(1,0));
if(mt->walls() & MT_W) mt->setWalls(mt->walls() - MT_W);
} else {
if(walls() & MT_W) setWalls(walls() - MT_W);
}
}
void Map::render ( const Ldouble& delta, graphics::TextureManager* textures , etc::Camera& camera )
{
std::vector<graphics::drawable*> tiles;
this->map.getSpritesFromArea( camera.getViewport() , &tiles );
for ( auto t : tiles )
{
MapTile* tile = (MapTile*)t;
tile->render( delta , textures , camera );
}
}
float MapMgr::GetZ(float x, float y)
{
GridCoordPair gcoords = GetTransformGridCoordPair(x,y);
MapTile *tile = _tiles->GetTile(gcoords.x,gcoords.y);
if(tile)
{
return tile->GetZ(x,y);
}
logerror("MapMgr::GetZ() called for not loaded MapTile (%u, %u) for (%f, %f)",gcoords.x,gcoords.y,x,y);
return INVALID_HEIGHT;
}
void BattleLayer::cardBattleLose()
{
removeChild(m_cardbattleLayer);
m_curTile->setMark(MapTile::None);
cocos2d::CCCallFunc* callback = CCCallFunc::create(this, callfunc_selector(BattleLayer::fight));
MapTile* nextTile = m_terrain->getTileByID(m_curTile->getNextTile());
m_enemySprite->runAction(CCSequence::create(CCMoveTo::create(1.0, nextTile->getPosition()),callback,NULL));
m_curTile = nextTile;
updateEnemyHpBar();
}
void DebugStyle::addData(TileData &_data, MapTile &_tile, const MapProjection &_mapProjection) {
if (Tangram::getDebugFlag(Tangram::DebugFlags::TILE_BOUNDS)) {
Mesh* mesh = new Mesh(m_vertexLayout, m_drawMode);
// Add four vertices to draw the outline of the tile in red
std::vector<PosColVertex> vertices;
GLuint abgr = 0xff0000ff;
vertices.reserve(4);
vertices.push_back({{ -1.f, -1.f, 0.f }, abgr });
vertices.push_back({{ 1.f, -1.f, 0.f }, abgr });
vertices.push_back({{ 1.f, 1.f, 0.f }, abgr });
vertices.push_back({{ -1.f, 1.f, 0.f }, abgr });
mesh->addVertices(std::move(vertices), { 0, 1, 2, 3, 0 });
mesh->compileVertexBuffer();
_tile.addGeometry(*this, std::unique_ptr<VboMesh>(mesh));
}
}
QPointF WarpTile::warpTo() {
if(!holeOpen)
return pos();
Q_ASSERT(targetTile);
holePixmap.setVisible(false);
holeOpen = false;
closedTimer.start(5000);
targetTile->warpTo();
if(position().x() < MAPW/2) {
MapTile *mt = playfield->tileAt(position() + QPoint(1,0));
mt->setWalls(mt->walls() | MT_W);
} else {
setWalls(walls() | MT_W);
}
return targetTile->pos();
}
std::shared_ptr<TileData> GeoJsonSource::parse(const MapTile& _tile, std::vector<char>& _rawData) const {
std::shared_ptr<TileData> tileData = std::make_shared<TileData>();
// parse written data into a JSON object
rapidjson::Document doc;
rapidjson::MemoryStream ms(_rawData.data(), _rawData.size());
rapidjson::EncodedInputStream<rapidjson::UTF8<char>, rapidjson::MemoryStream> is(ms);
doc.ParseStream(is);
if (doc.HasParseError()) {
size_t offset = doc.GetErrorOffset();
const char* error = rapidjson::GetParseError_En(doc.GetParseError());
logMsg("Json parsing failed on tile [%d, %d, %d]: %s (%u)\n", _tile.getID().z, _tile.getID().x, _tile.getID().y, error, offset);
return tileData;
}
// transform JSON data into a TileData using GeoJson functions
for (auto layer = doc.MemberBegin(); layer != doc.MemberEnd(); ++layer) {
tileData->layers.emplace_back(std::string(layer->name.GetString()));
GeoJson::extractLayer(layer->value, tileData->layers.back(), _tile);
}
// Discard original JSON object and return TileData
return tileData;
}
void MapMgr::_LoadTile(uint32 gx, uint32 gy, uint32 m)
{
_mapsLoaded = false;
if(!_tiles->TileExists(gx,gy))
{
if(TileExistsInFile(m,gx,gy))
{
logerror("MapMgr: Tile (%u, %u) exists not in WDT, but as file?!",gx,gy);
// continue loading...
}
else
{
logerror("MAPMGR: Not loading MapTile (%u, %u) map %u, no entry in WDT tile map",gx,gy,m);
return;
}
}
if( !_tiles->GetTile(gx,gy) )
{
char buf[300];
MakeMapFilename(buf,m,gx,gy);
MemoryDataHolder::MemoryDataResult mdr = MemoryDataHolder::GetFileBasic(buf);
if(mdr.flags & MemoryDataHolder::MDH_FILE_OK && mdr.data.size)
{
ByteBuffer bb(mdr.data.size);
bb.append(mdr.data.ptr,mdr.data.size);
MemoryDataHolder::Delete(buf);
ADTFile *adt = new ADTFile();
adt->LoadMem(bb);
logdebug("MAPMGR: Loaded ADT '%s'",buf);
MapTile *tile = new MapTile();
tile->ImportFromADT(adt);
delete adt;
_tiles->SetTile(tile,gx,gy);
logdebug("MAPMGR: Imported MapTile (%u, %u) for map %u",gx,gy,m);
}
else
{
logerror("MAPMGR: Loading ADT '%s' failed!",buf);
}
}
else
{
logdebug("MAPMGR: No need to load MapTile (%u, %u) map %u",gx,gy,m);
}
}
Bar::Bar(int i, int j, int xSize, int zSize) {
this->i = i;
this->j = j;
barPos = Vector3(i, 0, j);
barkeepTile = Vector3(i + 1, 0 , j + 1);
for (int index = i; index < i + xSize; index++) {
for (int index2 = j; index2 < j + zSize; index2++) {
if (index == i) {
patronTiles.push_back(Vector3(index - 1, 0, index2));
}
if (index2 == j) {
patronTiles.push_back(Vector3(index, 0, index2 - 1));
}
if (index == i + xSize -1) {
patronTiles.push_back(Vector3(index + 1, 0, index2));
}
if (index2 == j + zSize - 1) {
patronTiles.push_back(Vector3(index, 0, index2 + 1));
}
MapTile *barTile = GameData::getInstance()->getGameMap()->getMapTile(index, index2);
barTile->setPrimitive(new ScenePrimitive(ScenePrimitive::TYPE_BOX, 5, 8, 5), "WoodMaterial", 6, true);
}
}
for (int index = i + 1; index < i - 1 + xSize; index++) {
for (int index2 = j + 1; index2 < j - 1 + zSize; index2++) {
MapTile *barTile = GameData::getInstance()->getGameMap()->getMapTile(index, index2);
barTile->removeObject(index, index2);
}
}
MapTile * temp = GameData::getInstance()->getGameMap()->getMapTile(i + xSize - 2, j + 1);
temp->setObject("barrel_03.mesh", "BitgemMaterial", 4, true);
temp->getObject()->setScale(0.1, 0.1, 0.1);
SceneMesh *object = new SceneMesh("barrel_01.mesh");
object->depthTest = true;
object->depthWrite = true;
object->setPosition(i*5, 4.5, j*5);
object->setMaterialByName("BitgemMaterial");
object->setScale(0.06, 0.06, 0.06);
GameData::getInstance()->getScene3D()->addChild(object);
/*ScenePrimitive *objectShadow;
objectShadow = new ScenePrimitive(ScenePrimitive::TYPE_CIRCLE, 5, 5, 20);
objectShadow->setPitch(-90);
objectShadow->depthTest = true;
objectShadow->depthWrite = true;
objectShadow->setPosition(i*5, 6, i*5);
objectShadow->setMaterialByName("SolidMaterial");
objectShadow->setColor(1, 1, 1, 0.3);
GameData::getInstance()->getScene3D()->addChild(objectShadow);
*/
TavernResources::getInstance()->barList.push_back(this);
}
bool Map::undoPackage (int col, int row, int targetCol, int targetRow)
{
MapTile* package = getPackage(col, row);
if (package != nullptr) {
info(LOG_SERVER, "move package back");
rebuildField();
const int origCol = package->getCol();
const int origRow = package->getRow();
if (!package->setPos(targetCol, targetRow))
return false;
rebuildField();
const int index = INDEX(targetCol, targetRow);
StateMapConstIter i = _state.find(index);
if (i == _state.end()) {
package->setPos(origCol, origRow);
return false;
}
const char c = i->second;
if (c == Sokoban::PACKAGEONTARGET)
package->setState(CavePackerEntityStates::DELIVERED);
else
package->setState(CavePackerEntityStates::NONE);
--_pushes;
return true;
}
info(LOG_SERVER, "don't move package back");
return false;
}
bool BattleLayer::checkGuardBuff(int x, int y)
{
MapTile* tile = m_terrain->getTileByCoordinate(x, y);
if(!tile)
return false;
if(tile->getMark() == MapTile::Guard1)
{
m_preventEnemyBuff++;
m_enemycards[m_curEnemy]->buffHP(-0.1);
MapTile::TileMark mark = m_curTile->getMark();
if(mark == MapTile::Card1 || mark == MapTile::Card2 || mark == MapTile::Card3)
{
m_herocards[m_curTile->getMark()]->buffAtk(0.1);
}
m_guardLabel->setString("攻击守卫");
m_guardLabel->runAction(CCSequence::create(CCShow::create(), CCDelayTime::create(c_trapDelayTime), CCHide::create(), NULL));
return true;
}
if(tile->getMark() == MapTile::Guard2)
{
m_preventEnemyBuff++;
MapTile::TileMark mark = m_curTile->getMark();
if(mark == MapTile::Card1 || mark == MapTile::Card2 || mark == MapTile::Card3)
{
m_herocards[m_curTile->getMark()]->buffDef(0.1);
m_herocards[m_curTile->getMark()]->buffHP(0.3);
}
m_guardLabel->setString("守护守卫");
m_guardLabel->runAction(CCSequence::create(CCShow::create(), CCDelayTime::create(c_trapDelayTime), CCHide::create(), NULL));
return true;
}
return true;
}
unsigned int World::getAreaID()
{
MapTile *curTile;
int mtx,mtz,mcx,mcz;
mtx = (int) (camera.x / TILESIZE);
mtz = (int) (camera.z / TILESIZE);
mcx = (int) (fmod(camera.x, TILESIZE) / CHUNKSIZE);
mcz = (int) (fmod(camera.z, TILESIZE) / CHUNKSIZE);
if ((mtx<cx-1) || (mtx>cx+1) || (mtz<cz-1) || (mtz>cz+1)) return 0;
curTile = current[mtz-cz+1][mtx-cx+1];
if(curTile == 0) return 0;
MapChunk *curChunk = curTile->getChunk(mcx, mcz);
if(curChunk == 0) return 0;
return curChunk->areaID;
}
void BattleLayer::copyTerrainTile(TerrainMap *terrain)
{
if(m_terrain)
{
m_terrain->removeFromParent();
m_terrain = NULL;
}
m_terrain = new TerrainMap;
m_terrain->autorelease();
addChild(m_terrain);
CCArray* children = terrain->getChildren();
for (int i = children->count()-1; i > -1; i--)
{
MapTile* node = (MapTile*)children->objectAtIndex(i);
node->retain();
node->removeFromParent();
m_terrain->addTile(node);
node->release();
}
}
void MapTile::lock() {
if (state_ == DEADBEEF) {
return;
}
if (locked++ > 0) {
return;
}
MapTile *p;
for (int i = 0; i < 4; i++) {
p = (MapTile *)pNode->child(i);
if (p == NULL)
continue;
if (p->state(READY | NEW_DATA)) {
proxy |= (1 << i);
p->refs++;
}
}
if (pNode->isRoot())
return;
p = (MapTile *)pNode->parent();
if (p != NULL && p->state(READY | NEW_DATA)) {
proxy |= PROXY_PARENT;
p->refs++;
}
if (pNode->pParent->isRoot())
return;
p = (MapTile *)pNode->pParent->parent();
if (p != NULL && p->state(READY | NEW_DATA)) {
proxy |= PROXY_GRAMPA;
p->refs++;
}
}
void TileLoader::finishedRequest(QNetworkReply *reply) {
const QNetworkRequest request = reply->request();
// find corresponding tile
MapTile *tile = 0;
for (MapTile &t : tiles_) {
if (t.reply() == reply) {
tile = &t;
}
}
if (!tile) {
// removed from list already, ignore this reply
return;
}
if (reply->error() == QNetworkReply::NoError) {
// decode an image
QImageReader reader(reply);
if (reader.canRead()) {
QImage image = reader.read();
tile->setImage(image);
emit receivedImage(request);
} else {
// probably not an image
QString err;
err = "Unable to decode image at " + request.url().toString();
emit errorOcurred(err);
}
} else {
QString err;
err = "Failed loading " + request.url().toString();
err += " with code " + QString::number(reply->error());
emit errorOcurred(err);
}
emit finishedLoading();
}
void DebugTextStyle::addData(TileData& _data, MapTile& _tile, const MapProjection& _mapProjection) {
if (Tangram::getDebugFlag(Tangram::DebugFlags::TILE_INFOS)) {
onBeginBuildTile(_tile);
Mesh* mesh = new Mesh(m_vertexLayout, m_drawMode);
auto labelContainer = LabelContainer::GetInstance();
auto ftContext = labelContainer->getFontContext();
auto textBuffer = _tile.getTextBuffer(*this);
ftContext->setFont(m_fontName, m_fontSize * m_pixelScale);
if (m_sdf) {
float blurSpread = 2.5;
ftContext->setSignedDistanceField(blurSpread);
}
std::string tileID = std::to_string(_tile.getID().x) + "/" + std::to_string(_tile.getID().y) + "/" + std::to_string(_tile.getID().z);
labelContainer->addLabel(_tile, m_name, { glm::vec2(0), glm::vec2(0) }, tileID, Label::Type::DEBUG);
std::vector<PosTexID> vertices;
vertices.resize(textBuffer->getVerticesSize());
if (textBuffer->getVertices(reinterpret_cast<float*>(vertices.data()))) {
mesh->addVertices(std::move(vertices), {});
}
mesh->compileVertexBuffer();
_tile.addGeometry(*this, std::unique_ptr<VboMesh>(mesh));
onEndBuildTile(_tile);
}
}
bool Map::movePlayer (Player* player, char step)
{
int x;
int y;
getXY(step, x, y);
debug(LOG_SERVER, String::format("move player %i:%i (current: %i:%i)", x, y, player->getCol(), player->getRow()));
// move player and move touching packages
const int targetCol = player->getCol() + x;
const int targetRow = player->getRow() + y;
MapTile* package = getPackage(targetCol, targetRow);
if (package != nullptr) {
const int pCol = targetCol + x;
const int pRow = targetRow + y;
if (!isFree(pCol, pRow)) {
debug(LOG_SERVER, "can't move here - can't move package. target field is blocked");
return false;
}
if (!package->setPos(pCol, pRow)) {
debug(LOG_SERVER, "failed to move the package - thus can't move the player");
return false;
}
debug(LOG_SERVER, String::format("moved package %i", package->getID()));
increasePushes();
rebuildField();
if (isTarget(pCol, pRow)) {
package->setState(CavePackerEntityStates::DELIVERED);
debug(LOG_SERVER, String::format("mark package as delivered %i", package->getID()));
} else if (package->getState() == CavePackerEntityStates::DELIVERED) {
debug(LOG_SERVER, String::format("reset package state %i", package->getID()));
package->setState(CavePackerEntityStates::NONE);
}
// sokoban standard - if a package was moved, the move char is uppercase
step = toupper(step);
}
if (!player->setPos(targetCol, targetRow)) {
debug(LOG_SERVER, "failed to move the player");
return false;
}
player->storeStep(step);
increaseMoves();
return true;
}
//-----------------------------------------------------------------------------------------------
void PrepareForBattle( int playerID, const ArenaInfo& arenaInfo )
{
InitializeCriticalSection( &cs_ordersAndResults );
gameInfo.g_playerID = playerID;
gameInfo.g_arenaInfo = arenaInfo;
gameInfo.secondsSinceLastFetchOrders = GetAbsoluteTimeSeconds();
if( gameInfo.g_arenaInfo.numPlayers == 1 )
gameInfo.currentStrategy = GameInfo::STRATEGY_SOLO;
gameInfo.g_mapTiles = std::vector< MapTile >( arenaInfo.width * arenaInfo.height );
vec3 mapSize( arenaInfo.width, arenaInfo.height, 0.0f );
MapTile initializingDefaultGCosts;
initializingDefaultGCosts.setNodeTypeID( "dirt" );
initializingDefaultGCosts.setDefaultGCost( 0.5f );
initializingDefaultGCosts.setNodeTypeID( "stone" );
initializingDefaultGCosts.setDefaultGCost( 0.0f );
initializingDefaultGCosts.setNodeTypeID( "food" );
initializingDefaultGCosts.setNodeTypeID( "unknown" );
for( int y = 0; y < arenaInfo.height; ++y )
{
for( int x = 0; x < arenaInfo.width; ++x )
{
MapTile& currentTile = gameInfo.g_mapTiles[ y * arenaInfo.width + x ];
currentTile.setType( ARENA_SQUARE_TYPE_UNKNOWN );
currentTile.setPosition( vec3( x, y, 0.0f ) );
for( int sign = -1; sign <= 1; sign += 2 )
{
for( int axis = 0; axis < 2; ++axis)
{
vec3 neighorPos( x, y, 0.0f );
neighorPos[axis] += sign;
if( neighorPos[axis] >= 0 && neighorPos[axis] < mapSize[axis] )
{
currentTile.addNeighbor( &gameInfo.g_mapTiles[neighorPos.y * mapSize.x + neighorPos.x] );
}
}
}
}
}
//DebuggerPrintf( "[%d] PrepareForBattle called; arena is %dx%d, with %d players\n", g_playerID, arenaInfo.width, arenaInfo.height, arenaInfo.numPlayers );
}
