/** * For debugging, makes a square room on the map. * @param x1 * @param y1 * @param x2 * @param y2 */ void Area::boxRoom(const int x1, const int y1, const int x2, const int y2) { // Floor fill(x1+1, y1+1, x2-1, y2-1, TILE_FLOOR); // Top side fill(x1+1, y1, x2-1, y1, TILE_WALL, true, -90.0f); // Left side fill(x1, y1+1, x1, y2-1, TILE_WALL, true); // Right side fill(x2, y1+1, x2, y2-1, TILE_WALL, true, 180.0f); // Bottom side fill(x1+1, y2, x2-1, y2, TILE_WALL, true, 90.0f); // TL setTile(x1, y1, new Tile(TILE_INNERCORNER)); setRotation(x1, y1, -90.0f); setSolid(x1, y1); // BL setTile(x1, y2, new Tile(TILE_INNERCORNER)); setSolid(x1, y2); // TR setTile(x2, y1, new Tile(TILE_INNERCORNER)); setRotation(x2, y1, -180.0f); setSolid(x2, y1); // BR setTile(x2, y2, new Tile(TILE_INNERCORNER)); setRotation(x2, y2, 90.0f); setSolid(x2, y2); }
void PanelButton::configure() { QString name = tileName(); if( name.isEmpty() ) return; if (!KickerSettings::enableTileBackground()) { setTile(QString::null); return; } KConfigGroup tilesGroup( KGlobal::config(), "button_tiles" ); if( !tilesGroup.readBoolEntry( "Enable" + name + "Tiles", true ) ) { setTile( QString::null ); return; } QString tile = tilesGroup.readEntry( name + "Tile" ); QColor color = QColor(); if (tile == "Colorize") { color = tilesGroup.readColorEntry( name + "TileColor" ); tile = QString::null; } setTile( tile, color ); }
void Level::processPlayerMove(Player &player, int x, int y) { int playerX; int playerY; player.getLocation(playerX, playerY); char moveTile; moveTile = getTile(x, y); switch (moveTile) { case '.': player.setLocation(x,y); setTile(playerX,playerY, '.'); setTile(x,y, '@'); } }
void Map::make_rectangle(int x, int y, int width, int height) { for(int i = x; i < x + width; i++) { for(int j = y; j < y + height; j++) { if(i == x || i == x + width - 1 || j == y || j == y + height - 1) { // We're on the border. Set a border tile if there's not ile set already if(!map.count(std::make_pair(i, j))) { setTile(i, j, Tile('#', false)); } } else { // We need to carve out a passable place setTile(i, j, Tile('.', true)); } } } }
void CCShakyTiles3D::update(cocos2d::ccTime time) { int i, j; for (i = 0; i < m_sGridSize.x; ++i) { for (j = 0; j < m_sGridSize.y; ++j) { ccQuad3 coords = originalTile(ccg(i, j)); // X coords.bl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.br.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tr.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; // Y coords.bl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.br.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tr.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; if (m_bShakeZ) { coords.bl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.br.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tr.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; } setTile(ccg(i, j), coords); } } }
void CCTurnOffTiles::turnOffTile(cocos2d::ccGridSize pos) { ccQuad3 coords; memset(&coords, 0, sizeof(ccQuad3)); setTile(pos, coords); }
void CCShakyTiles3D::update(float time) { CC_UNUSED_PARAM(time); int i, j; for (i = 0; i < m_sGridSize.width; ++i) { for (j = 0; j < m_sGridSize.height; ++j) { ccQuad3 coords = originalTile(ccp(i, j)); // X coords.bl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.br.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tr.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange; // Y coords.bl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.br.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tr.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange; if (m_bShakeZ) { coords.bl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.br.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; coords.tr.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange; } setTile(ccp(i, j), coords); } } }
void ShakyTiles3D::update(float time) { CC_UNUSED_PARAM(time); int i, j; for (i = 0; i < _gridSize.width; ++i) { for (j = 0; j < _gridSize.height; ++j) { Quad3 coords = getOriginalTile(Point(i, j)); // X coords.bl.x += ( rand() % (_randrange*2) ) - _randrange; coords.br.x += ( rand() % (_randrange*2) ) - _randrange; coords.tl.x += ( rand() % (_randrange*2) ) - _randrange; coords.tr.x += ( rand() % (_randrange*2) ) - _randrange; // Y coords.bl.y += ( rand() % (_randrange*2) ) - _randrange; coords.br.y += ( rand() % (_randrange*2) ) - _randrange; coords.tl.y += ( rand() % (_randrange*2) ) - _randrange; coords.tr.y += ( rand() % (_randrange*2) ) - _randrange; if (_shakeZ) { coords.bl.z += ( rand() % (_randrange*2) ) - _randrange; coords.br.z += ( rand() % (_randrange*2) ) - _randrange; coords.tl.z += ( rand() % (_randrange*2) ) - _randrange; coords.tr.z += ( rand() % (_randrange*2) ) - _randrange; } setTile(Point(i, j), coords); } } }
void TurnOffTiles::turnOffTile(const Point& pos) { Quad3 coords; memset(&coords, 0, sizeof(Quad3)); setTile(pos, coords); }
void JumpTiles3D::update(float time) { int i, j; float sinz = (sinf((float)M_PI * time * _jumps * 2) * _amplitude * _amplitudeRate ); float sinz2 = (sinf((float)M_PI * (time * _jumps * 2 + 1)) * _amplitude * _amplitudeRate ); for( i = 0; i < _gridSize.width; i++ ) { for( j = 0; j < _gridSize.height; j++ ) { Quad3 coords = getOriginalTile(Point(i, j)); if ( ((i+j) % 2) == 0 ) { coords.bl.z += sinz; coords.br.z += sinz; coords.tl.z += sinz; coords.tr.z += sinz; } else { coords.bl.z += sinz2; coords.br.z += sinz2; coords.tl.z += sinz2; coords.tr.z += sinz2; } setTile(Point(i, j), coords); } } }
void Map::createEmptyTiles() { // Create tiles and set coordinates. for (unsigned int j = 0; j < rows(); j++) { for (unsigned int i = 0; i < cols(); i++) { if (!getTile(i, j)) { TrackTileBase * newTile = new TrackTile( static_cast<TrackData &>(trackData()), QPointF(TrackTile::TILE_W / 2 + i * TrackTile::TILE_W, TrackTile::TILE_H / 2 + j * TrackTile::TILE_H), QPoint(i, j)); setTile(i, j, TrackTilePtr(newTile)); } else { getTile(i, j)->setLocation( QPointF( TrackTile::TILE_W / 2 + i * TrackTile::TILE_W, TrackTile::TILE_H / 2 + j * TrackTile::TILE_H)); getTile(i, j)->setMatrixLocation(QPoint(i, j)); } } } }
void CCTurnOffTiles::turnOffTile(const CCPoint& pos) { ccQuad3 coords; memset(&coords, 0, sizeof(ccQuad3)); setTile(pos, coords); }
//t is for type bool TavernExpansion::makeExpansion(String tileMat, int t) { int rowChange = row / 2; int colChange = col / 2; String tMat = "GridMaterial"; getBorders(); if (this->viableExpansion() == true) { TavernResources::getInstance()->removeGold(row * col * TavernResources::getInstance()->getTilePrice()); TavernResources::getInstance()->incrementTilePrice(); TavernResources::getInstance()->addBuildRep(row * col * 20); TavernResources::getInstance()->calcRep(); for (int dRow = -rowChange; dRow <= rowChange; dRow++) { for (int dCol = -colChange; dCol <= colChange; dCol++) { if (centerPos.x + dRow > 0 && centerPos.x + dRow < DIM - 1 && centerPos.y + dCol > 0 && centerPos.y + dCol < DIM - 1) { setTile(dRow, dCol, tMat, TILE, true); setTE(dRow, dCol, true); } } } configureTiles(tMat); //redoBotWalls(); return true; } return false; }
void CCJumpTiles3D::update(float time) { int i, j; float sinz = (sinf((float)M_PI * time * m_nJumps * 2) * m_fAmplitude * m_fAmplitudeRate ); float sinz2 = (sinf((float)M_PI * (time * m_nJumps * 2 + 1)) * m_fAmplitude * m_fAmplitudeRate ); for( i = 0; i < m_sGridSize.width; i++ ) { for( j = 0; j < m_sGridSize.height; j++ ) { ccQuad3 coords = originalTile(ccp(i, j)); if ( ((i+j) % 2) == 0 ) { coords.bl.z += sinz; coords.br.z += sinz; coords.tl.z += sinz; coords.tr.z += sinz; } else { coords.bl.z += sinz2; coords.br.z += sinz2; coords.tl.z += sinz2; coords.tr.z += sinz2; } setTile(ccp(i, j), coords); } } }
void TileInfoView::onActiveUnitChanged(Unit* unit) { if (unit) { setTile(unit->tile()); } }
void TileMapEditTestNew::updateMap(float dt) { // IMPORTANT // The only limitation is that you cannot change an empty, or assign an empty tile to a tile // The value 0 not rendered so don't assign or change a tile with value 0 auto tilemap = (TileMapAtlas*) getChildByTag(kTagTileMap); // // For example you can iterate over all the tiles // using this code, but try to avoid the iteration // over all your tiles in every frame. It's very expensive // for(int x=0; x < tilemap.tgaInfo->width; x++) { // for(int y=0; y < tilemap.tgaInfo->height; y++) { // Color3B c =[tilemap tileAt:Size(x,y)); // if( c.r != 0 ) { // ////----CCLOG("%d,%d = %d", x,y,c.r); // } // } // } // NEW since v0.7 Color3B c = tilemap->getTileAt(Vec2(13,21)); c.r++; c.r %= 50; if( c.r==0) c.r=1; // NEW since v0.7 tilemap->setTile(c, Vec2(13,21) ); }
void TileMap::tick() { std::vector<glm::uvec2> toSet; std::vector<TileId> ids; for(auto animated = mAnimatedTiles.begin(); animated != mAnimatedTiles.end();) { if(animated->second.mTimeLeft == 0) { uint32_t x = animated->first.x; uint32_t y = animated->first.y; TileId id = animated->second.mNext; animated = mAnimatedTiles.erase(animated); toSet.push_back(glm::uvec2(x, y)); ids.push_back(id); continue; } else { animated->second.mTimeLeft--; animated++; } } for(uint32_t i = 0; i < toSet.size(); i++) { setTile(toSet[i], ids[i], PRESERVE); } }
void FoW::reset(FogStatus value) { for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { status[i][j] = value; setTile(j, i, (value == HIDDEN)? ALL : NONE); } } }
/* move player (and box) from one position to another on the board */ int moveTo(int fromX, int fromY, int toX, int toY) { int box = 0; setTile(fromX, fromY, getGridTile(fromX, fromY)); char next = getTile(toX, toY); if (next == TARGET) setTile(toX, toY, PLAYER_ON_TARGET); else if (next == BOX || next == BOX_ON_TARGET) { box = 1; next = getGridTile(toX, toY); if (next == BLANK) setTile(toX, toY, PLAYER); else if (next == TARGET) { setTile(toX, toY, PLAYER_ON_TARGET); increaseRemaining(); } int newMovableY = toY+(toY-fromY); int newMovableX = toX+(toX-fromX); char newMovablePos = getTile(newMovableX, newMovableY); if (newMovablePos == BLANK) setTile(newMovableX, newMovableY, BOX); else if (newMovablePos == TARGET) { setTile(newMovableX, newMovableY, BOX_ON_TARGET); decreaseRemaining(); } } else if (next == BLANK) setTile(toX, toY, PLAYER); return box; }
// Called in level. This function does the same as setTile, but also draws directly to the scrollsurface // used normally, when items are picked up bool CMap::changeTile(Uint16 x, Uint16 y, Uint16 t) { if( setTile( x, y, t ) ) { m_Tilemaps.at(1).drawTile(g_pVideoDriver->getScrollSurface(), (x<<4)&511, (y<<4)&511, t); return true; } return false; }
FOR_EACH (Path::const_iterator, i, road) { const Position &pos = (*i); MapItem *const item = getTile(pos.x, pos.y); if (!item) setTile(pos.x, pos.y, new MapItem(MapItemType::ROAD)); else item->setType(MapItemType::ROAD); }
/** * Fills an area with tiles. * @param x1 Start x coordinate. * @param y1 Start y coordinate. * @param x2 End x coordinate. * @param y2 End y coordinate. * @param filename Tile's model filename. * @param solidness The tile's solid state. * @param rotation Tile's rotation. */ void Area::fill(const int x1, const int y1, const int x2, const int y2, const string filename, const bool solidity, const float rotation) { for(int y = y1; y <= y2; y++) { for(int x = x1; x <= x2; x++) { setTile(x, y, new Tile(filename)); setRotation(x, y, rotation); setSolid(x, y, solidity); } } }
bool createFeature(int x, int y, Direction dir) { static const int roomChance = 50; // corridorChance = 100 - roomChance int dx = 0; int dy = 0; if (dir == North) dy = 1; else if (dir == South) dy = -1; else if (dir == West) dx = 1; else if (dir == East) dx = -1; if (getTile(x + dx, y + dy) != Floor && getTile(x + dx, y + dy) != Corridor) return false; if (randomInt(100) < roomChance) { if (makeRoom(x, y, dir)) { setTile(x, y, ClosedDoor); return true; } } else { if (makeCorridor(x, y, dir)) { if (getTile(x + dx, y + dy) == Floor) setTile(x, y, ClosedDoor); else // don't place a door between corridors setTile(x, y, Corridor); return true; } } return false; }
void editor::listenToMouse() { if (levelLoaded) { if (pressedL) { int x = floor((xMouseReal-xCorner)/double(tilesize)); int y = level.h - floor((yMouseReal-yCorner)/double(tilesize)) - 1; switch (mode) { case 0: case 1: case 2: try { setTile(x, y, mode, mode?selectedColor:(char *)"#ffffff", selectedDurability); } catch (...) {} updateTile(x, y); break; case 3: if (x>=0 && y>=0 && x<level.w && y<level.h && tileType(x, y)) { int h=0, s=0, v=0; int c = 0; for (int i=-1; i<2; i++) for (int j=-1; j<2; j++, c++) { try { QColor tmp(tileColor(x+i, y+j)); h += tmp.hue(); s += tmp.saturation(); v += tmp.value(); } catch (...) { QColor tmp(tileColor(x+(-1*i), y+(-1*j))); h += tmp.hue(); s += tmp.saturation(); v += tmp.value(); } } h /= c; s /= c; v /= c; QColor q; q.setHsv(h, s, v); char m[8]; for (int i=0; i<8; i++) m[i] = (q.name().constData()+i)->toAscii(); qstrcpy(tileColor(x, y), m); updateTile(x, y); break; } } } } }
Tile::Tile(int _x, int _y, int _layer, int texNum, double _direction){ tile_t temp; x=_x; y=_y; layer=_layer; direction=_direction; temp.texName=texNum; temp.on=1; t = setTile(x,y,layer,temp); }
void GridSystem::processEntity(Entity *entity, const float dt) { auto grid = static_cast<GridComponent*>(entity->getComponent(GridComponent::Type)); // ############### // Do the grid simulation if (grid->mID == -1) { grid->mID = mNextGridID; mNextGridID++; } // Iterate through cached interesting tiles that need to be operated on for (unsigned int t = 0; t < mTicks.size(); t++) { if (mTicks[t].mClock.getElapsedTime().asSeconds() < mTicks[t].mDelay) continue; mTicks[t].mClock.restart(); //if (grid->mCTiles[t].size()) // std::cout << "Tick!\n"; //std::cout << grid->mCTiles[t].size() << std::endl; if (mTicks[t].mOp.getType() == GridOp::STATIC) { std::vector<Area> areas; for (auto coord : grid->mCTiles[t]) { Area a = grid->getArea(coord.x, coord.y); // New tile a = mTicks[t].mOp(a); if (a.mChanged) areas.push_back(a); } grid->clearInteresting(t); //if (areas.size() > 0) // std::cout << "Areas: " << areas.size() << std::endl; for (auto a : areas) { grid->setTile(a.mX, a.mY, a.mTiles[1][1], t); } } else { mTicks[t].mOp(grid, t); grid->clearInteresting(t); } } }
void wyLeftLineShrinkOut::transformTile(wyDimension pos, float distance) { wyQuad3D coords = getOriginalTile(pos); wyPoint step = wyp(m_target->getGrid()->getStepWidth(), m_target->getGrid()->getStepHeight()); coords.bl_x += (step.x / 2) * (1.0f - distance); coords.br_x -= (step.x / 2) * (1.0f - distance); coords.tl_x += (step.x / 2) * (1.0f - distance); coords.tr_x -= (step.x / 2) * (1.0f - distance); setTile(pos, coords); }
// Called in level. This function does the same as setTile, but also draws directly to the scrollsurface // used normally, when items are picked up bool CMap::changeTile(Uint16 x, Uint16 y, Uint16 t) { const int drawMask = gVideoDriver.getScrollSurface()->w-1; if( setTile( x, y, t ) ) { m_Tilemaps.at(1).drawTile(gVideoDriver.getScrollSurface(), (x<<4)&drawMask, (y<<4)&drawMask, t); return true; } return false; }
void CCFadeOutUpTiles::transformTile(const CCPoint& pos, float distance) { ccQuad3 coords = originalTile(pos); CCPoint step = m_pTarget->getGrid()->getStep(); coords.bl.y += (step.y / 2) * (1.0f - distance); coords.br.y += (step.y / 2) * (1.0f - distance); coords.tl.y -= (step.y / 2) * (1.0f - distance); coords.tr.y -= (step.y / 2) * (1.0f - distance); setTile(pos, coords); }
void FadeOutUpTiles::transformTile(const Point& pos, float distance) { Quad3 coords = getOriginalTile(pos); Point step = _target->getGrid()->getStep(); coords.bl.y += (step.y / 2) * (1.0f - distance); coords.br.y += (step.y / 2) * (1.0f - distance); coords.tl.y -= (step.y / 2) * (1.0f - distance); coords.tr.y -= (step.y / 2) * (1.0f - distance); setTile(pos, coords); }